;;; Mode: Lisp; Package: ocml ;;; File created in WebOnto (in-package "OCML") (in-ontology lpmo) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;; lpmo descriptions;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_description (#_sdpo:description) ((has-title :type string) (has-description :type string) (d-uses :type #_parameter))) (def-class #_actor-profile (#_description) ((d-uses :type #_parameter))) (def-class #_object-description (#_description) ((d-uses :type #_object-parameter))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;; lpmo context and situation ;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_situation (#_sdpo:situation)) (def-class #_state-situation (#_situation) ((has-part :type #_state-situation) (part-of :type #_state-situation) (satisfies :type #_state-description))) (def-class #_state-description (#_description) ?sd ((d-uses :type #_situation-parameter :min-cardinality 2)) :constraint (exists (?r ?s) (and (d-uses ?sd ?r) (#_functional-role ?r) (d-uses ?sd ?s) (#_parameter ?s)))) (def-class #_mobile-state-situation (#_state-situation) ((has-part :type #_mobile-state-situation) (part-of :type #_mobile-state-situation) (satisfies :type #_mobile-state-description))) (def-class #_mobile-state-description (#_description) ?sd ((d-uses :type #_mobile-situation-parameter :min-cardinality 2)) :constraint (exists (?r ?s) (and (d-uses ?sd ?r) (#_functional-role ?r) (d-uses ?sd ?s) (#_parameter ?s)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;; lpmo parameter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_parameter (#_sdpo:situation-parameter) ((has-instance-title :type string) (has-parameter-title :type string))) (def-class #_situation-parameter (#_parameter)) (def-class #_state-parameter (#_situation-parameter)) (def-class #_mobile-situation-parameter (#_parameter)) (def-class #_mobile-state-parameter (#_mobile-situation-parameter)) (def-class #_object-parameter (#_parameter)) (def-class #_aim (#_state-parameter) ((has-parameter-title :value "Aim") (defined-by :type (or (#_aim-description aim-member))))) (def-class #_mobile-aim (#_mobile-state-parameter) ((has-parameter-title :value "Aim") (defined-by :type (or (#_aim-description aim-member))))) (def-class #_aim-description (#_description) ((d-uses :type #_competency))) (def-class #_state-location (#_mobile-state-parameter) ((has-parameter-title :value "Situational Location"))) (def-class #_profile-parameter (#_situation-parameter)) (def-class #_competency (#_profile-parameter) ((level :type string) (has-parameter-title :value "Competency") (has-description :type string) (is-equivalent-to :type #_equivalent-competencies-list) (is-similar-to :type #_similar-competencies-list) (hasAssociatedDomainConcepts :type list) (targets-location :type #_location) (targets-aim :type #_aim) (requires-comp :type #_requires-competencies-list))) (def-class #_gap-parameter (#_state-parameter #_mobile-state-parameter) ((has-parameter-title :value "Competency Gap"))) (def-class #_equivalent-competencies-list (list)) (def-class #_similar-competencies-list (list)) (def-class #_requires-competencies-list (list)) (def-class #_technical-environment (#_profile-parameter) ((has-parameter-title :value "Technical Environment"))) (def-class #_educational-method (#_profile-parameter) ((has-parameter-title :value "Educational Method"))) (def-class #_learning-style (#_profile-parameter) ((has-parameter-title :value "Learning Style") (defined-by :type #_css:fslsm-member))) (def-class #_prototypical-learning-style (#_profile-parameter) ((has-parameter-title :value "Prototypical Learning Style") (defined-by :type #_css:fslsm-prototypical-member))) (def-class #_location (#_profile-parameter #_mobile-state-parameter) ((has-parameter-title :value "Location") (defined-by :type #_css:location-member))) (def-class #_latitude (#_mobile-state-parameter) ((has-parameter-title :value "Latitude"))) (def-class #_longitude (#_mobile-state-parameter) ((has-parameter-title :value "Longitude"))) (def-class #_profile-interaction-type (#_profile-parameter) ((has-parameter-title :value "Actor Interaction") (defined-by :value #_css:interaction-member))) (def-class #_state-interaction-type (#_state-parameter #_mobile-state-parameter) ((has-parameter-title :value "Situational Interaction"))) (def-class #_learning-time (#_mobile-state-parameter #_state-parameter) ((has-min-time :type integer) (has-max-time :type integer) (has-parameter-title :value "Learning Time"))) (def-class #_state-language (#_mobile-state-parameter #_state-parameter) ((has-parameter-title :value "Situational Language"))) (def-class #_runtime-environment (#_technical-environment) ((supports-standard :type #_metadata-standard) (has-parameter-title :value "Runtime Environment"))) (def-class #_metadata-standard (#_state-parameter) ((has-parameter-title :value "Metadata Standard"))) (def-class #_profile-language (#_profile-parameter) ((has-parameter-title :value "Actor Language"))) (def-class #_actor (#_parameter) ((defined-by :type #_actor-profile) (has-parameter-title :value "Actor"))) (def-class #_resource (#_parameter) ((targets :type #_goal))) (def-class #_domain (#_parameter) ((has-parameter-title "Domain"))) (def-class #_service (#_resource)) (def-class #_object (#_resource) ((has-parameter-title :value "Object") (defined-by :type #_object-description))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;; lpmo process (parameters...) ;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_goal-description (#_description) ((has-effect :type #_state-description) (has-assumption :type #_state-description))) (def-class #_action-goal-description (#_goal-description)) (def-class #_support-goal-description (#_goal-description)) (def-class #_get-situation-parameters-goal-description (#_support-goal-description)) (def-class #_get-competency-gap-goal-description (#_support-goal-description)) (def-class #_get-actor-profile-goal-description (#_support-goal-description)) (def-class #_flow-element (#_parameter) ((part-of :type #_composite-process-entity) (has-predecessor :type #_flow-element) (has-successor :type #_flow-element))) (def-class #_goal (#_flow-element) ?lg ((plays :type #_goal-role) (defined-by :type #_goal-description) (adressess-aim :type #_aim)) :constraint (exists (?r ?s) (and (plays ?lg ?r) (#_action-goal-role ?r) (defined-by ?lg ?s) (#_action-goal-description ?s))) :constraint (exists (?t ?u) (and (plays ?lg ?t) (#_process-goal-role ?t) (defined-by ?lg ?u) (#_process-goal-description ?u))) :constraint (exists (?v ?w) (and (plays ?lg ?v) (#_support-goal-role ?v) (defined-by ?lg ?w) (#_support-goal-description ?w)))) (def-class #_process () ?lp ((defined-by :type #_process-description) (targets :type #_goal)) :constraint (for-all (?x ?y) (and (targets ?lp ?x) (#_goal ?x) (plays ?x ?y) (#_process-goal-role ?y)))) (def-class #_action-type (#_parameter)) (def-class #_process-entity (#_flow-element) ((targets :type #_goal) (type :type #_actiont-type) (has-predecessor :type #_flow-element :max-cardinality 1) (has-successor :type #_flow-element :max-cardinality 1))) (def-class #_action-type (#_parameter)) (def-class #_assessment-type (#_action-type)) (def-class #_learning-type (#_action-type)) (def-class #_action-entity (#_process-entity) ?ae () :constraint (for-all (?x ?y) (and (targets ?ae ?x) (#_goal ?x) (plays ?x ?y) (#_action-goal-role ?y)))) (def-class #_composite-process-entity (#_process-entity) ((has-part :type #_flow-element))) (def-class #_action-entity-sequence (#_composite-process-entity) ((has-part :type #_action-entity))) (def-class #_control-flow-entity (#_flow-element)) (def-class #_loop-entity (#_control-flow-entity) ((executes :type #_process-entity))) (def-class #_loop-until-entity (#_loop-entity)) (def-class #_loop-while-entity (#_loop-entity)) (def-class #_intersection-entity (#_control-flow-entity) ?ie :constraint (exists (?r ?s) (and (has-successor ?ie ?r) (not (#_intersection-entity ?r)) (has-predecessor ?ie ?s) (not (#_intersection-entity ?s))))) (def-class #_merge-entity (#_intersection-entity) ((has-predecessor :type #_process-entity :min-cardinality 2))) (def-class #_simple-merge-entity (#_merge-entity)) (def-class #_synchronization-entity (#_merge-entity)) (def-class #_branch-entity (#_intersection-entity) ((has-successor :type #_process-entity :min-cardinality 2))) (def-class #_multiple-choice-entity (#_branch-entity)) (def-class #_exclusive-choice-entity (#_branch-entity)) (def-class #_parallel-split-entity (#_branch-entity)) (def-class #_process-description (#_description) ?pd ((d-uses :min-cardinality 2)) :constraint (exists (?r ?s ?t) (and (d-uses ?pd ?r) (#_goal ?r) (d-uses ?pd ?s) (#_flow-element ?s)))) (def-class #_condition ()) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;; lpmo roles ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_role (#_sdpo:situation-role) ((has-title :type string))) (def-class #_description-role (#_role)) (def-class #_goal-role (#_description-role) ((played-by :type #_goal))) (def-class #_action-goal-role (#_goal-role)) (def-class #_process-goal-role (#_goal-role)) (def-class #_support-goal-role (#_goal-role)) (def-class #_functional-role (#_role)) (def-class #_actor-role (#_functional-role) ((played-by :type #_actor))) (def-class #_learner-role (#_actor-role)) (def-class #_resource-role (#_functional-role) ((played-by :type #_resource))) (def-class #_repository-role (#_resource-role) ((played-by :type #_repository))) (def-class #_repository (#_resource) ((has-parameter-title :value "Repository") (has-url :type string) (has-description :type string) (targetsLanguage :type list) (targetsDomain :type list) (targetsCompetency :type list) (targetsCompetencyInDomain :type list))) ;;; repository instances (def-instance #_oai-language-rep #_repository ((has-instance-title "OAI-LANGUAGE-REP") (has-url "http://www.lang.ltsn.ac.uk/oai/oai.aspx") (has-description "Higher Education Academy Repository for Languages & Linguistics") (targetsLanguage ("French" "English")) (targetsDomain (linguistic languages)) (targetsCompetency (basic-french-comp expert-french-comp advanced-french-comp)) (targetsCompetencyInDomain (linguistic-french-language basic-french-in-languages-competency advanced-french-in-languages-competency)) )) (def-instance #_open-learn-language-rep #_repository ((has-instance-title "OPEN-LEARN-LANGUAGE-REP") (has-url "http://openlearn.open.ac.uk/course/category.php?id=9") (has-description "Modern Languages in Open Learn") (targetsLanguage ("English")) (targetsDomain (managerial languages linguistic)) (targetsCompetency (expert-french-comp basic-french-comp advanced-french-comp)) (targetsCompetencyInDomain (managerial-french-language basic-french-in-languages-competency advanced-french-in-languages-competency)) )) (def-instance #_open-learn-history-rep #_repository ((has-instance-title "OPEN-LEARN-ARTS-AND-HISTORY-REPOSITORY") (has-url "http://openlearn.open.ac.uk/course/category.php?id=3") (has-description "Arts and History in Open Learn") (targetsLanguage ("English")) (targetsDomain (history ol-arts-history)) (targetsCompetency (basic-brighton-pavillion-comp advanced-brighton-pavillion-comp)) )) (def-instance #_open-learn-maths-rep #_repository ((has-instance-title "OPEN-LEARN-MATHS-REP") (has-url "http://openlearn.open.ac.uk/course/category.php?id=8") (has-description "Mathematics and Statistics in Open Learn") (targetsLanguage ("English")) (targetsDomain (maths)) (targetsCompetency (basic-maths-comp expert-maths-comp advanced-maths-comp)) (targetsCompetencyInDomain (basic-maths-in-maths-competency differential-equations-in-maths-competency fourier-modelling-in-maths-competency)) )) (def-instance #_open-learn-live-rep #_repository ((has-instance-title "OPEN-LEARN-LIVE-REPOSITORY") (has-url "http://www.open.ac.uk/openlearn/") (has-description "Live Query on the Open Learn Resources.") (targetsLanguage ("English")) (targetsDomain (maths managerial linguistic ol-arts-history ol-business-management ol-society ol-study-skills ol-how-to ol-education ol-health-lifestyle ol-it-computing ol-mathematics-statistics ol-modern-languages ol-science-nature ol-technology)) (targetsCompetency (basic-maths-comp expert-maths-comp advanced-maths-comp)) (targetsCompetencyInDomain (basic-maths-in-maths-competency differential-equations-in-maths-competency fourier-modelling-in-maths-competency)) )) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;; metadata representations ;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_metadata-representation (#_sdpo:description)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;; ims ld from here ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_imsld-representation (#_metadata-representation) ((has-title :type string) (has-id :type string) ;;;#_imsld-compliant ids without blanks (refines :type (or(#_process-description #_parameter))))) (def-class #_imsld-component (#_imsld-representation) ()) (def-class #_imsld-design (#_imsld-representation) ?id ((refines :type #_process-description) (has-method :type #_imsld-method) (has-components :type #_imsld-components) (targets :type #_imsld-objective)) :constraint (exists (?r ?s ?t) (and (targets ?id ?r) (#_imsld-objective ?r) (refines ?r ?s) (#_goal ?s) (plays ?s ?t) (#_process-goal-role ?t)))) (def-class #_imsld-activity-entity (#_imsld-component) ((refines :type #_process-entity) (has-scuccessor :type #_imsld-activity-entity) (has-predecessor :type #_imsld-activity-entity) (is-visible :type boolean))) (def-class #_imsld-activity (#_imsld-activity-entity) ?ia ((refines :type #_action-entity) (has-description :type #_imsld-activity-description) (has-completion :type (or (#_imsld-user-choice #_imsld-time-limit #_imsld-valued-property))) (has-environment :type #_imsld-environment) (targets :type #_imsld-objective)) :constraint (exists (?r ?s ?t) (and (targets ?ia ?r) (#_imsld-objective ?r) (refines ?r ?s) (#_goal ?s) (plays ?s ?t) (#_action-goal-role ?t)))) (def-class #_imsld-user-choice (#_imsld-representation) ((has-completion-value :type boolean))) (def-class #_imsld-time-limit (#_imsld-representation) ()) (def-class #_imsld-learning-activity (#_imsld-activity) ()) (def-class #_imsld-support-activity (#_imsld-activity) ()) (def-class #_imsld-activity-description (#_imsld-representation) ((grounded-to :type #_imsld-item))) (def-class #_imsld-activity-structure (#_imsld-activity-entity) ?as ((refines :type #_composite-process-entity) (has-activity-ref :type #_imsld-activity :min-cardinality 1)) :constraint (exists (?r ?s ?t) (and (refines ?as ?r) (#_composite-process-entity ?r) (has-part ?r ?s) (#_action-entity ?s)))) (def-class #_imsld-environment (#_imsld-component) ((is-visible :type boolean) (composed-of :type #_imsld-environment-entity))) (def-class #_imsld-environment-entity (#_imsld-representation) ((refines :type #_resource))) (def-class #_imsld-learning-object (#_imsld-environment-entity) ((refines :type #_object) (grounded-to :type #_imsld-item))) (def-class #_imsld-learning-service (#_imsld-environment-entity) ((refines :type #_service) (grounded-to :type #_imsld-item))) (def-class #_imsld-item (#_imsld-representation) ?ii ((refines :type #_resource) (is-visible :type boolean) (has-href :type string)) :constraint (exists (?r ?s) (and (has-href ?ii ?r) (#_imsld-resource ?s) (has-href ?r)))) (def-class #_imsld-resource (#_imsld-representation) ((refines :type #_resource) (has-href :type string))) (def-class #_imsld-method (#_imsld-representation) ((has-play :type #_imsld-play :min-cardinality 1) (has-conditions :type #_imsld-condition))) (def-class #_imsld-play (#_imsld-representation) ((has-act :type #_imsld-act :min-cardinality 1))) (def-class #_imsld-act (#_imsld-representation) ((has-role-part :type #_imsld-role-part :min-cardinality 1))) (def-class #_imsld-objective (#_imsld-representation) ((refines :type #_goal) (has-objective-description :type #_imsld-objective-description))) (def-class #_imsld-objective-description (#_imsld-representation) ((refines :type #_goal-description) (grounded-to :type #_imsld-item))) (def-class #_imsld-role (#_imsld-component) ((refines :type #_actor-role))) (def-class #_imsld-role-part (#_imsld-representation) ((has-role-ref :type #_imsld-role) (has-acitivity-ref :type #_imsld-activity-entity) (has-environment-ref :type #_imsld-environment))) (def-class #_imsld-property (#_imsld-component) ((refines :type #_parameter) (has-datatype :type #_imsld-datatype) (has-current-value :type #_imsld-valued-property) (has-initial-value :type #_imsld-valued-property) (has-restriction :type #_imsld-restriction))) (def-class #_imsld-valued-property (#_imsld-component) ((refines :type #_parameter) (has-property :type #_imsld-property) (has-value :type string))) (def-class #_imsld-datatype (#_imsld-representation) ()) (def-class #_imsld-restriction (#_imsld-representation) ((has-restriction :type string))) (def-class #_imsld-global-property (#_imsld-property) ((has-uri :type string))) (def-class #_imsld-local-property (#_imsld-property) ((has-uri :type string))) (def-class #_imsld-condition (#_imsld-representation) ((refines :type #_parameter) (has-property-ref :type #_imsld-property))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; adlscorm alignment from here ;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (def-class #_adlscorm-representation (#_metadata-representation) ((has-title :type string))) (def-class #_adlscorm-organization (#_adlscorm-representation) ?ao ((refines :type (or(#_process-description #_composite-process-entity))) (targets :type #_adlscorm-objective) ;;; only implicit defined as part of the sequencing (follows :type #_adlscorm-sequencing)) :constraint (exists (?r ?s ?t) (and (targets ?ao ?r) (#_adlscorm-objective ?r) (refines ?r ?s) (#_goal ?s) (plays ?s ?t) (#_process-goal-role ?t)))) (def-class #_adlscorm-item (#_adlscorm-representation) ?ai ((refines :type #_action-entity) (grounded-to :type #_adlscorm-resource) (is-visible :type boolean) (targets :type #_adlscorm-objective) ;;; only implicitly defined as part of the sequencing (follows :type #_adlscorm-sequencing)) :constraint (exists (?r ?s ?t) (and (targets ?ai ?r) (#_adlscorm-objective ?r) (refines ?r ?s) (#_goal ?s) (plays ?s ?t) (#_action-goal-role ?t)))) (def-class #_adlscorm-resource (#_adlscorm-representation) ((refines :type #_object) (has-href :type string) (has-type :type #_adlscorm-type) (has-scorm-type :type #_adlscorm-scorm-type))) (def-class #_adlscorm-scorm-type (#_adlscorm-representation)) (def-class #_adlscorm-sco-type (#_adlscorm-scorm-type)) (def-class #_adlscorm-asset-type (#_adlscorm-scorm-type)) (def-class #_adlscorm-type (#_adlscorm-representation)) (def-class #_adlscorm-web-type (#_adlscorm-type)) (def-class #_adlscorm-text-type (#_adlscorm-type)) (def-class #_adlscorm-sequencing (#_adlscorm-representation) ((d-uses :type #_adlscorm-sequencing-parameter))) (def-class #_adlscorm-sequencing-parameter (#_adlscorm-representation)) (def-class #_adlscorm-objective (#_adlscorm-sequencing-parameter) ((refines :type #_goal))) (def-class #_adlscorm-global-objective (#_adlscorm-objective)) (def-class #_adlscorm-primary-objective (#_adlscorm-objective)) (def-class #_adlscorm-rollup-rule (#_adlscorm-sequencing-parameter) ((has-rollup-condition :type #_adlscorm-rollup-condition) (has-rollup-action :type #_adlscorm-rollup-action))) (def-class #_adlscorm-control-mode (#_adlscorm-sequencing-parameter)) (def-class #_adlscorm-delivery-control (#_adlscorm-sequencing-parameter)) (def-class #_adlscorm-rollup-condition (#_adlscorm-sequencing-parameter)) (def-class #_adlscorm-rollup-action (#_adlscorm-sequencing-parameter)) (def-class #_adlscorm-sequencing-rule (#_adlscorm-sequencing-parameter)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;; INSTANCES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;aims (def-instance french-expert-aim #_aim ((has-instance-title "Learning French (Expert Level)") (defined-by french-expert-aim-description))) (def-instance french-expert-aim-description #_aim-description ((d-uses (basic-french-comp advanced-french-comp expert-french-comp)))) (def-instance french-basic-aim #_aim ((has-instance-title "Learning French (Basic Level)") (defined-by french-basic-aim-description))) (def-instance french-basic-aim-description #_aim-description ((d-uses (basic-french-comp)))) (def-instance french-advanced-aim #_aim ((has-instance-title "Learning French (Advanced Level)") (defined-by french-advanced-aim-description))) (def-instance french-advanced-aim-description #_aim-description ((d-uses (basic-french-comp advanced-french-comp)))) (def-instance maths-advanced-aim #_aim ((has-instance-title "Learning Maths (Advanced Level)") (defined-by maths-advanced-aim-description))) (def-instance maths-advanced-aim-description #_aim-description ((d-uses (basic-maths-comp advanced-maths-comp)))) (def-instance maths-expert-aim #_aim ((has-instance-title "Learning Maths (Expert Level)") (defined-by maths-expert-aim-description))) (def-instance maths-expert-aim-description #_aim-description ((d-uses (basic-maths-comp advanced-maths-comp expert-maths-comp diff-equations-comp)))) (def-instance maths-basic-aim #_aim ((has-instance-title "Learning Maths (Basic Level)") (defined-by maths-basic-aim-description))) (def-instance maths-basic-aim-description #_aim-description ((d-uses (basic-maths-comp)))) ;;;mobile aims (def-instance geography-aim #_mobile-aim ((has-instance-title "Local Geography") (defined-by #_css:p3-geography-aim))) (def-instance culture-aim #_mobile-aim ((has-instance-title "Local Culture") (defined-by #_css:p4-culture-aim))) (def-instance history-aim #_mobile-aim ((has-instance-title "Local History") (defined-by #_css:p2-history-aim))) (def-instance local-language-aim #_mobile-aim ((has-instance-title "Local Language") (defined-by #_css:p1-language-aim))) (def-instance local-language-culture-aim #_mobile-aim ((has-instance-title "Local Language and Culture") (defined-by language-culture-aim-description #_css:a1-language-culture-aim))) (def-instance language-culture-aim-description #_aim-description ((d-uses (basic-french-comp advanced-french-comp expert-french-comp basic-german-comp basic-spanish-comp)))) (def-instance local-history-culture-aim #_mobile-aim ((has-instance-title "Local History and Culture") (defined-by history-culture-aim-description #_css:a2-history-culture-aim))) (def-instance history-culture-aim-description #_aim-description ((d-uses (basic-brighton-pavillion-comp advanced-brighton-pavillion-comp east-anglia-comp)))) (def-instance local-geography-history-aim #_mobile-aim ((has-instance-title "Local Geography and History") (defined-by geography-history-aim-description #_css:a3-geography-history-aim))) (def-instance geography-history-aim-description #_aim-description ((d-uses (east-anglia-comp)))) ;;; locations (def-instance france-location #_location ((has-instance-title "France"))) (def-instance germany-location #_location ((has-instance-title "Germany") (defined-by #_css:p8-location-germany))) (def-instance london-location #_location ((has-instance-title "London") (defined-by #_css:p1-location-london))) (def-instance brighton-location #_location ((has-instance-title "Brighton, UK") (defined-by #_css:p2-location-brighton))) (def-instance milton-keynes-location #_location ((has-instance-title "Milton Keynes, UK") (defined-by #_css:p3-location-milton-keynes))) (def-instance paris-location #_location ((has-instance-title "Paris, FR") (defined-by #_css:p4-location-paris))) (def-instance toulouse-location #_location ((has-instance-title "Toulouse, FR") (defined-by #_css:p5-location-toulouse))) (def-instance italy-location #_location ((has-instance-title "Italy"))) (def-instance spain-location #_location ((has-instance-title "Spain") ( defined-by #_css:p9-location-spain))) (def-instance uk-location #_location ((has-instance-title "UK") (defined-by #_css:p6-location-uk))) (def-instance france-location #_location ((has-instance-title "France") (defined-by #_css:p7-location-france))) (def-instance germany-location #_location ((has-instance-title "Germany") (defined-by #_css:p8-location-germany))) (def-instance us-location #_location ((has-instance-title "United States"))) (def-instance participative-method #_educational-method ((has-instance-title "Participative"))) (def-instance non-participative-method #_educational-method ((has-instance-title "Non-Participative"))) ;;; reusable roles and parameters from here (def-instance default-process-goal-role #_process-goal-role ((has-title "Default Process Goal Role"))) (def-instance default-action-goal-role #_action-goal-role ((has-title "Default Action Goal Role"))) (def-instance french-advanced-lo #_object) (def-instance french-expert-lo #_object) (def-instance learner-role #_learner-role ((has-title "Default Learner"))) (def-instance state-interactive-type #_state-interaction-type ((has-instance-title "Interactive"))) (def-instance state-non-interactive-type #_state-interaction-type ((has-instance-title "Non-Interactive"))) (def-instance profile-interactive-type #_profile-interaction-type ((has-instance-title "Interactive"))) (def-instance profile-non-interactive-type #_profile-interaction-type ((has-instance-title "Non-Interactive"))) (def-instance brad-interactive-type #_profile-interaction-type ((has-instance-title "Brad's Interactivity") (defined-by #_css:i1-brad-p-interaction-member))) (def-instance angie-interactive-type #_profile-interaction-type ((has-instance-title "Angie's Interactivity") (defined-by #_css:i2-angie-interaction-member))) (def-instance imsld-standard #_metadata-standard ((has-instance-title "IMS LD"))) (def-instance #_adlscorm-standard #_metadata-standard ((has-instance-title "ADL SCORM"))) (def-instance reload-#_adlscorm-rte #_runtime-environment ((has-instance-title "Reload ADL SCORM Player") (supports-standard adl-scorm-standard))) (def-instance reload-imsld-rte #_runtime-environment ((has-instance-title "Reload IMS LD Player") (supports-standard imsld-standard))) (def-instance semantic-#_rte #_runtime-environment ((has-instance-title "LPMO Runtime Environment"))) (def-instance short-learning-time #_learning-time ((has-instance-title "Short") (has-min-time 0) (has-max-time 9))) (def-instance medium-learning-time #_learning-time ((has-instance-title "Medium") (has-min-time 10) (has-max-time 15))) (def-instance long-learning-time #_learning-time ((has-instance-title "Long") (has-min-time 16))) (def-instance english-state-language #_state-language ((has-instance-title "English"))) (def-instance french-state-language #_state-language ((has-instance-title "French"))) (def-instance spanish-state-language #_state-language ((has-instance-title "Spanish"))) (def-instance english-profile-language #_profile-language ((has-instance-title "English"))) (def-instance french-profile-language #_profile-language ((has-instance-title "French"))) (def-instance spanish-profile-language #_profile-language ((has-instance-title "Spanish"))) (def-instance brad-p-learning-style #_learning-style ((has-instance-title "Brad P.'s Learning Style") (defined-by fslsm-brad-p-style))) (def-instance angie-j-learning-style #_learning-style ((has-instance-title "Angie J.'s Learning Style") (defined-by fslsm-angie-j-style))) (def-instance p1-active-visual-style #_prototypical-learning-style ((has-instance-title "Active-Visual Learning Style") ( defined-by fslsm-p1-active-visual-style))) (def-instance p2-reflective-style #_prototypical-learning-style ((has-instance-title "Reflective Learning Style") ( defined-by fslsm-p2-reflective-style))) (def-instance p3-sensing-sequential-style #_prototypical-learning-style ((has-instance-title "Sensing-Sequential Learning Style") ( defined-by fslsm-p3-sensing-sequential-style))) (def-instance p4-intuitive-global-style #_prototypical-learning-style ((has-instance-title "Intuitive-Global Learning Style") ( defined-by fslsm-p4-intuitive-global-style))) (def-instance p5-verbal-style #_prototypical-learning-style ((has-instance-title "Verbal Learning Style") ( defined-by fslsm-p5-verbal-style))) (def-instance brad-profile #_actor-profile ((has-title "Brads Profile") (d-uses (basic-french-comp basic-english-comp basic-maths-comp profile-interactive-type participative-method english-profile-language brad-p-learning-style us-location)))) (def-instance brad-actor #_actor ((has-instance-title "Brad P.") (defined-by brad-profile))) (def-instance guest-profile #_actor-profile ((has-title "Guest Profile") (d-uses (profile-interactive-type participative-method english-profile-language uk-location)))) (def-instance guest-actor #_actor ((has-instance-title "Guest") (defined-by guest-profile))) (def-instance angie-profile #_actor-profile ((has-title "Angies Profile ") (d-uses (basic-french-comp basic-maths-comp profile-interactive-type non-participative-method us-location english-profile-language angie-j-learning-style)))) (def-instance angie-actor #_actor ((has-instance-title "Angie J.") (defined-by angie-profile))) ;;; process dependent elements and situation descriptions (def-instance french-basic-state-description #_state-description ((has-title "Initial state") (d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role)))) (def-instance french-advanced-state-description #_state-description ((has-title "French advanced state") (d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role french-advanced-lo)))) (def-instance french-expert-state-description #_state-description ((has-title "French Expert State") (d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role advanced-french-comp expert-french-comp)))) (def-instance french-advanced-comp-state-description #_state-description ((has-title "French Advanced Learned State") (d-uses (basic-french-comp basic-maths-comp interactive-type semantic-#_rte learner-role advanced-french-comp)))) (def-instance french-basic-situation #_state-situation ((satisfies french-basic-state-description))) (def-instance french-advanced-situation #_state-situation ((satisfies french-advanced-state-description))) (def-instance french-expert-situation #_state-situation ((satisfies french-expert-state-description))) (def-instance french-advanced-comp-situation #_state-situation ((satisfies french-advanced-comp-state-description))) (def-instance basic-german-comp #_competency ((has-instance-title "Basic German Competency") (targets-aim (culture-aim)) (targets-location (germany-location)) (hasAssociatedDomainConcepts (german-concept)) (level "Introductory"))) (def-instance basic-german-language-comp #_competency ((has-instance-title "Basic German Language Competency") (targets-aim (local-language-aim)) (targets-location (germany-location)) (hasAssociatedDomainConcepts (german-language-concept)) (level "Introductory"))) (def-instance basic-spanish-comp #_competency ((has-instance-title "Basic Spanish Competency") (targets-aim (local-language-aim)) (targets-location (spain-location)) (hasAssociatedDomainConcepts (spanish-language-concept)) (level "Introductory"))) (def-instance basic-english-comp #_competency ((has-instance-title "Basic English Competency") (targets-location (uk-location)) (targets-aim (local-language-aim)) (is-similar-to (english-grammar-comp)) (hasAssociatedDomainConcepts (english-language-concept)) (level "Introductory"))) (def-instance english-grammar-comp #_competency ((has-instance-title "English Grammar in Context Competency") (targets-location (uk-location)) (targets-aim (local-language-aim)) (requires-comp (basic-english-comp)) (is-similar-to (basic-english-comp)) (hasAssociatedDomainConcepts (english-language-concept english-grammar-concept)) (level "Advanced"))) (def-instance east-anglia-comp #_competency ((has-instance-title "East Anglia History Competency") (targets-location (uk-location)) (targets-aim (local-geography-history-aim culture-aim)) (requires-comp (basic-english-comp)) (is-similar-to (basic-brighton-pavillion-comp advanced-brighton-pavillion-comp)) (hasAssociatedDomainConcepts (east-anglia-concept)) (level "Introductory"))) (def-instance basic-french-comp #_competency ((has-instance-title "Basic French Competency") (has-description "Familiarity with the basic vocabulary and grammtical concepts of the French language.") (is-similar-to (advanced-french-comp beginners-french-comp expert-french-comp)) (targets-aim (french-basic-aim local-language-aim)) (is-equivalent-to (beginners-french-comp)) (requires-comp (french-foundations-comp)) (targets-location (france-location)) (hasAssociatedDomainConcepts (french-language-concept)) (level "Introductory"))) (def-instance general-france-comp #_competency ((has-instance-title "General France Competency") (has-description "Background on french history and culture.") (is-similar-to (advanced-french-comp beginners-french-comp expert-french-comp basic-french-comp)) (targets-aim (history-aim culture-aim)) (requires-comp (french-foundations-comp)) (targets-location (france-location)) (hasAssociatedDomainConcepts (france-concept)) (level "Introductory"))) (def-instance beginners-french-comp #_competency ((has-instance-title "French Beginners Competency") (is-similar-to (advanced-french-comp)) (is-equivalent-to (basic-french-comp)) (targets-aim (local-language-aim)) (targets-location (france-location)) (hasAssociatedDomainConcepts (french-language-concept)) (level "Introductory"))) (def-instance louvre-comp #_competency ((has-instance-title "Louvre Competency") (is-similar-to (advanced-french-comp basic-french-competency)) (targets-aim (culture-aim)) (targets-location (paris-location)) (hasAssociatedDomainConcepts (louvre-concept)) (level "Introductory"))) (def-instance french-foundations-comp #_competency ((has-instance-title "French Foundations Competency") (is-similar-to (advanced-french-comp basic-french-comp)) (targets-aim (local-language-aim)) (targets-location (french-location)) (hasAssociatedDomainConcepts (french-language-concept)) (level "Introductory"))) (def-instance advanced-french-comp #_competency ((has-instance-title "Advanced French Competency") (has-description "Advanced capabilities of French language. Familiarity with grammar and wide range of vocabulary.") (is-similar-to (basic-french-comp expert-french-comp beginners-french-comp french-foundations-comp)) (targets-location (france-location)) (targets-aim (local-language-aim)) (is-equivalent-to (advanced-french-comp)) (requires-comp (basic-french-comp beginners-french-comp french-foundations-comp)) (hasAssociatedDomainConcepts (french-language-concept french-grammar-concept)) (level "Advanced"))) (def-instance expert-french-comp #_competency ((has-instance-title "Expert French Competency") (has-description "Expert-level capabilities of French language. Proficiency with grammar and wide range of vocabulary.") (is-similar-to (advanced-french-comp basic-french-comp beginners-french-comp french-foundations-comp)) (targets-location (france-location)) (requires-comp (basic-french-comp advanced-french-comp beginners-french-comp french-foundations-comp)) (hasAssociatedDomainConcepts (french-language-concept french-grammar-concept)) (targets-location (france-location paris-location)) (targets-aim (local-language-aim)) (level "Expert"))) (def-instance basic-brighton-pavillion-comp #_competency ((has-instance-title "Introduction to the Brighton Pavillion") (is-similar-to (advanced-brighton-pavillion-comp)) (targets-location (brighton-location)) (targets-aim (culture-aim)) (is-similar-to (advanced-brighton-pavillion-comp)) (hasAssociatedDomainConcepts (brighton-pavillion-culture-concept brighton-pavillion-history-concept)) (level "Introductory"))) (def-instance advanced-brighton-pavillion-comp #_competency ((has-instance-title "Advanced Background on the Brighton Area") (targets-location (brighton-location)) (targets-aim (culture-aim)) (is-similar-to (basic-brighton-pavillion-comp)) (hasAssociatedDomainConcepts (brighton-pavillion-history-concept brighton-pavillion-culture-concept)) ;;need to introduce another domain concept (targets-location (uk-location brighton-location)) (level "Advanced"))) (def-instance advanced-maths-comp #_competency ((has-instance-title "Advanced Maths Competency") (has-description "Advanced understanding of mathematical concepts.") (hasAssociatedDomainConcepts (maths-basics-concept differential-equations-concept)) (requires-comp (beginners-maths-comp basic-maths-comp)) (is-similar-to (expert-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp)) (level "Advanced"))) (def-instance diff-equations-comp #_competency ((has-instance-title "Differential Equations Competency") (has-description "Ability to deal with differential equations.") (hasAssociatedDomainConcepts (maths-basics-concept differential-equations-concept)) (requires-comp (beginners-maths-comp basic-maths-comp)) (is-similar-to (expert-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp)) (level "Advanced"))) (def-instance expert-maths-comp #_competency ((has-instance-title "Expert Maths Competency") (has-description "Expert understanding of mathematical concepts.") (hasAssociatedDomainConcepts (differential-equations-concept fourier-series-concept)) (requires-comp (beginners-maths-comp basic-maths-comp advanced-maths-comp)) (is-similar-to (advanced-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp)) (level "Expert"))) (def-instance fourier-series-comp #_competency ((has-instance-title "Modelling with Fourier Series Competency") (hasAssociatedDomainConcepts (differential-equations-concept fourier-series-concept)) (requires-comp (beginners-maths-comp basic-maths-comp advanced-maths-comp expert-maths-comp)) (is-similar-to (advanced-maths-comp introductory-maths-comp beginners-maths-comp basic-maths-comp expert-maths-comp)) (level "Expert"))) (def-instance basic-maths-comp #_competency ((has-instance-title "Basic Maths Competency") (has-description "Familiarity with basic mathematical concepts.") (targets-aim (maths-basic-aim)) (requires-comp (beginners-maths-comp)) (hasAssociatedDomainConcepts (maths-basics-concept)) (is-equivalent-to (introductory-maths-comp)) (is-similar-to (advanced-maths-comp expert-maths-comp introductory-maths-comp beginners-maths-comp)) (level "Introductory"))) (def-instance beginners-maths-comp #_competency ((has-instance-title "Beginners Maths Competency") (has-description "Foundational understanding of mathematical concepts.") (hasAssociatedDomainConcepts (maths-basics-concept)) (is-similar-to (advanced-maths-comp expert-maths-comp basic-maths-comp)) (level "Introductory"))) (def-instance introductory-maths-comp #_competency ((has-instance-title "Introductory Maths Competency") (hasAssociatedDomainConcepts (maths-basics-concept)) (is-equivalent-to (basic-maths-comp)) (is-similar-to (advanced-maths-comp expert-maths-comp)) (level "Introductory"))) (def-class #_process-goal-description (#_goal-description) ((has-postcondition :type #_aim))) (def-instance french-exp-interact-semantic-goal-desc #_process-goal-description ((has-title "Contextualized French Expert Goal Description") (has-assumption french-basic-situation) (has-postcondition french-expert-aim) (has-description "Learning French at the Expert Level by using interactive learning objects and no specific metadata RTE"))) (def-instance french-advanced-goal-desc #_action-goal-description ((has-title "French Advanced Goal Description") (has-assumption french-basic-situation) (has-effect french-advanced-situation) (has-description "Learning French at the Expert Level by using interactive learning objects and no specific metadata RTE"))) (def-instance french-expert-goal-desc #_action-goal-description ((has-title "Contextualized French Expert Goal Description") (has-assumption french-advanced-comp-situation) (has-effect french-expert-situation) (has-description "Learning French at the Expert Level by using interactive learning objects and no specific metadata RTE"))) (def-instance french-assessment-goal-desc #_action-goal-description ((has-title "French Assessment Goal") (has-assumption french-advanced-situation) (has-effect (french-advanced-situation french-advanced-comp-situation)) (has-description "Assessing the French Skills of the Learner"))) (def-instance french-exp-interact-semantic-goal #_goal ((has-instance-title "Contextualized French Expert Goal") (plays default-process-goal-role) (defined-by french-exp-interact-semantic-goal-desc))) (def-instance french-advanced-goal #_goal ((has-instance-title "French Advanced Goal") (plays default-action-goal-role) (defined-by french-advanced-goal-desc))) (def-instance french-expert-goal #_goal ((has-instance-title "French Expert Goal") (plays default-action-goal-role) (defined-by french-expert-goal-desc))) (def-instance french-assessment-goal #_goal ((has-instance-title "French Assessment Goal") (plays default-action-goal-role) (defined-by french-assessment-goal-desc))) (def-instance french-expert-process #_process ((defined-by french-expert-process-description) (targets french-exp-interact-semantic-goal))) (def-instance french-expert-process-description #_process-description ((d-uses (french-exp-interact-semantic-goal french-advanced-goal french-expert-goal french-assessment-goal french-advanced-activity french-assessment-activity french-expert-activity french-advanced-split)))) (def-instance french-advanced-activity #_action-entity ((targets french-advanced-goal) (has-successor french-expert-activity))) (def-instance french-assessment-activity #_action-entity ((targets french-assessment-goal) (has-successor french-advanced-split-activity))) (def-instance french-expert-activity #_action-entity ((targets french-expert-goal) (has-predecessor french-advanced-activity))) (def-instance french-advanced-split #_exclusive-choice-entity ((has-predecessor french-assessment-activity) (has-successor french-advanced-activity french-expert-activity))) (def-instance imsld-design-french-expert #_imsld-design ((refines french-expert-process-description) (targets imsld-french-expert-interact-process-objective))) (def-instance imsld-french-advanced-activity #_imsld-activity ((refines french-advanced-activity) (targets imsld-french-advanced-objective))) (def-instance imsld-french-expert-activity #_imsld-activity ((refines french-expert-activity) (targets imsld-french-expert-objective))) (def-instance imsld-french-assessment-activity #_imsld-activity ((refines french-assessment-activity) (targets imsld-french-assessment-objective))) (def-instance imsld-french-assessment-objective #_imsld-objective ((refines french-assessment-goal))) (def-instance imsld-french-advanced-objective #_imsld-objective ((refines french-advanced-goal))) (def-instance imsld-french-expert-objective #_imsld-objective ((refines french-expert-goal))) (def-instance imsld-french-expert-objective #_imsld-objective ((refines french-expert-goal))) (def-instance imsld-french-expert-interact-process-objective #_imsld-objective ((refines french-expert-interact-semantic-goal))) (def-instance imsld-french-expert-act-structure #_imsld-activity-structure ((has-activity-ref imsld-french-advanced-activity imsld-french-expert-activity imsld-french-assessment-activity))) (def-instance imsld-french-learner #_imsld-role ((refines learner-role))) ;;; adlscorm process instances (def-instance adlscorm-french-expert-org #_adlscorm-organization ((targets adlscorm-french-expert-interact-process-objective) (refines french-expert-process-description))) (def-instance adlscorm-french-assessment-objective #_adlscorm-objective ((refines french-assessment-goal))) (def-instance adlscorm-french-advanced-objective #_adlscorm-objective ((refines french-advanced-goal))) (def-instance adlscorm-french-expert-objective #_adlscorm-objective ((refines french-expert-goal))) (def-instance adlscorm-french-expert-interact-process-objective #_adlscorm-objective ((refines french-expert-interact-semantic-goal))) (def-instance adlscorm-french-advanced-activity #_adlscorm-item ((refines french-advanced-activity) (targets adlscorm-french-advanced-objective))) (def-instance adlscorm-french-expert-activity #_adlscorm-item ((refines french-expert-activity) (targets adlscorm-french-expert-objective))) (def-instance adlscorm-french-assessment-activity #_adlscorm-item ((refines french-assessment-activity) (targets adlscorm-french-assessment-objective))) ;; lifting functions (deflift lift-competency-list #_parameter () (("has-instance-title" "XMLCompetencyList/Parameter/ParameterValue/text()"))) (deflift lift-situation-parameter #_situation-parameter () (("has-instance-title" "Parameter/ParameterValue/text()") ("has-parameter-title" "Parameter/ParameterTitle/text()"))) (deflift lift-situation #_state-description () (("d-uses" (lift-situation-parameter '("Situation/Parameter") :AS-VALUES)))) (deflower lower-parameter #_parameter (lambda (uses) (let ((res "") (tagname (ocml::the-slot-value uses 'ocml::has-parameter-title))) (setf tagname (remove #\Space tagname)) (setf res (concatenate 'string res "<")) (setf res (concatenate 'string res tagname)) (setf res (concatenate 'string res ">")) ;(setf res (concatenate 'string res (internal-lower-#_parameter uses))) (setf res (concatenate 'string res (ocml::the-slot-value uses 'ocml::has-instance-title))) (setf res (concatenate 'string res ""))))) (deflower lower-interaction-type #_interaction-type '(("Interaction" "has-instance-title"))) ;get gap analasys (deflower lower-competency-name #_competency '(("Competency" "has-instance-title"))) (deflower lower-aim-name #_aim '(("AimName" "has-instance-title"))) (deflower lower-competency #_competency '(("CompetencyDescription" (("Name" "has-instance-title") ("Description" "has-description") (lower-#_competency-targets-aim "targets-aim") (lower-#_competency-equivalents "is-equivalent-to") (lower-#_competency-similars "is-similar-to") (lower-#_competency-requirements "requires-comp") ; (lower-competency-component "hasComponent") ("Level" "level"))))) (def-class #_targets-aims-list (list)) (deflower lower-competency-targets-aim #_targets-aims-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (lower-aim-name comp)) ;;; (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) (deflower lower-competency-equivalents #_equivalent-competencies-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (lower-competency-name comp)) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) (deflower lower-competency-similars #_similar-competencies-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (lower-competency-name comp)) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) (deflower lower-competency-requirements #_requires-competencies-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (lower-competency-name comp)) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) ;;; lowering for lpmo repositories (def-class #_repository-and-domain-list (list)) (deflower lower-repository-and-domain-list repository-and-domain-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (print comp) (setf l (lower-repository (first comp))) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) (def-class targeted-language-list (list)) (def-class targeted-domain-list (list)) (def-class targeted-competency-list (list)) (def-class targeted-competency-in-domain-list (list)) (deflower lower-repository #_repository '(("RepositoryDescription" (("Name" "has-instance-title") ("Description" "has-description") ("Url" "has-url") (lower-#_repository-languages "targetsLanguage") (lower-#_repository-domains "targetsDomain") (lower-#_repository-competency-domain "targetsCompetencyInDomain"))))) (deflower lower-repository-languages targeted-language-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (concatenate 'string "" comp)) (setf l (concatenate 'string l "")) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) (deflower lower-repository-domains targeted-domain-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (lower-domain-name comp)) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) (deflower lower-repository-competency-domain targeted-competency-in-domain-list (lambda (equi) (let ((res "") (l nil)) (loop for comp in equi do (setf l (lower-competency-in-domain comp)) (setf res (concatenate 'string res l))) (setf res (concatenate 'string res ""))))) ;; FURTHER LIFTING and LOWERING DISTANCES: (defparameter *max-distance* 6.0) (def-class distance-data () ((has-member-title :type string) (has-prototype-distance :type prototype-distance) (has-smallest-prototype-distance :type prototype-distance))) (def-class prototype-distance () ((has-prototype-title :type string) (has-distance :type float))) (deflift lift-prototype-distance prototype-distance () (("has-prototype-title" "Distance/PrototypeTitle/text()") ("has-distance" "Distance/PrototypeDistance/text()"))) (deflift lift-smallest-prototype-distance prototype-distance () (("has-prototype-title" "SmallestDistance/PrototypeTitle/text()") ("has-distance" "SmallestDistance/PrototypeDistance/text()"))) (deflift lift-distance-data distance-data () (("has-member-title" "DistancesResults/Member/text()") ("has-prototype-distance" (lift-prototype-distance '("DistancesResults/Distance") :AS-VALUES)) ("has-smallest-prototype-distance" (lift-smallest-prototype-distance '("DistancesResults/SmallestDistance") :AS-VALUES))))