汽车诊断系统code

 KNOWLEDGE-MODEL Diagnosis;
/* ---------------------------------------------------------------------------------------*/
   DOMAIN-KNOWLEDGE car-domain;
      DOMAIN-SCHEMA car-schema;
          /* ------------CONCEPTS------------*/
          CONCEPT car-observable;
              ATTRIBUTES:
                  value:universal;
          END CONCEPT car-observable;
         
          VALUE-TYPE dial-value;
              VALUE-LIST:{ zero , low , normal };
              TYPE:ORDINAL;
          END VALUE-TYPE dial-value;
         
          CONCEPT gas-dial;
              SUB-TYPE-OF:car-observable;
              ATTRIBUTES:
                  value:dial-value;
          END CONCEPT gas-dial;
         
          CONCEPT fuse-inspection;
              SUB-TYPE-OF:car-observable;
              ATTRIBUTES:
                  value:{normal , broken};
          END CONCEPT gas-dial;
         
          CONCEPT battery-dial;
              SUB-TYPE-OF:car-observable;
              ATTRIBUTES:
                  value:dial-value;
          END CONCEPT gas-dial;
         
          CONCEPT car-state;
              ATTRIBUTES:
                  status:universal;
                  observable:boolean;
          END CONCEPT car-state;
         
          CONCEPT invisible-car-state;
              SUB-TYPE-OF:car-state;
              ATTRIBUTES:
                  observable:{false};
          END CONCEPT invisible-car-state; 
         
          CONCEPT visible-car-state;
              SUB-TYPE-OF:car-state;
              ATTRIBUTES:
                  observable:{true};
          END CONCEPT visible-car-state; 
         
          CONCEPT engine-behavior;
              SUB-TYPE-OF:visible-car-state;
              ATTRIBUTES:
                  status:{normal,does-not-start,stops};
          END CONCEPT visible-car-state; 
         
          CONCEPT fuse;
              SUB-TYPE-OF:in-visible-car-state;
              ATTRIBUTES:
                  status:{normal,blown};
          END CONCEPT fuse;
         
          CONCEPT battery;
              SUB-TYPE-OF:in-visible-car-state;
              ATTRIBUTES:
                  status:{normal,low};
          END CONCEPT battery;
         
          CONCEPT fuel-tank;
              SUB-TYPE-OF:in-visible-car-state;
              ATTRIBUTES:
                  status:{full,almost-empty,empty};
          END CONCEPT fuel-tank;
         
          CONCEPT power;
              SUB-TYPE-OF:in-visible-car-state;
              ATTRIBUTES:
                  status:{on,off};
          END CONCEPT power;
         
          CONCEPT gas-in-engine;
              SUB-TYPE-OF:in-visible-car-state;
              ATTRIBUTES:
                  status:boolean;
          END CONCEPT power;
          /* ------------CONCEPTS------------*/
         
          /* ------------RULE-TYPES----------*/
          RULE-TYPE state-dependency;
              ANTECEDENT : invisible-car-state;
                 CARDINALITY : 1;
              CONSEQUENT : car-state;
                 CARDINALITY : 1;
              CONNECTION-SYMBOL:
                 causes;
          END RULE-TYPE state-dependency;

          RULE-TYPE manifestation-rule;
              ANTECEDENT : invisible-car-state;
                 CONSEQUENT : car-observable;
              CONNECTION-SYMBOL:
                 has-manifestation;
          END RULE-TYPE manifestation-rule;
          /* ------------RULE-TYPES----------*/
  
      END DOMAIN-SCHEMA diagnosis-schema;
     
      KNOWLEDGE-BASE car-network;
          USES:
              state-dependency FROM car-schema,
              manifestation-rule FROM car-schema;
          EXPRESSIONS:
          /* state dependencies */
              fuse.status = blown CAUSES power.status = off; // 2
              battery.status = low CAUSES power.status = off; // 3
              power.status = off CAUSES engine-behavior.status = does-not-start; // 7
              fuel-tank.status = empty CAUSES gas-in-engine.status = false; // 6
              gas-in-engine.status = false CAUSES engine-behavior.status = does-not-start; // 8
              gas-in-engine.status = false CAUSES engine-behavior.status = stops; // 9

         /* manifestation rules */
              fuse.status = blown HAS-MANIFESTATION fuse-inspection.value = broken; // 1
              battery.status = low HAS-MANIFESTATION battery-dial.value = zero; // 4
              fuel-tank.status = empty HAS-MANIFESTATION gas-dial.value = zero; // 5
      END KNOWLEDGE-BASE car-network;
 
   END DOMAIN-KNOWLEDGE car-domain;
/* ---------------------------------------------------------------------------------------*/
   INFERENCE-KNOWLEDGE diagnosis-inferences;
      KNOWLEDGE-ROLE complaint;
          TYPE:DYNAMIC;
          DOMAIN-MAPPING : visible-state;
      END KNOWLEDGE-ROLE complaint;

      KNOWLEDGE-ROLE hypothesis;
          TYPE:DYNAMIC;
          DOMAIN-MAPPING : invisible-state;
      END KNOWLEDGE-ROLE complaint;

      KNOWLEDGE-ROLE causual-model;
          TYPE:STATIC;
          DOMAIN-MAPPING : state-dependency FROM car-network;
      END KNOWLEDGE-ROLE causual-model;
     
      INFERENCE cover;
          ROLES:
              INPUT : complaint;
              OUTPUT : hypothesis;
              STATIC : causual-model;
      END INFERENCE cover;
   END INFERENCE-KNOWLEDGE diagnosis-inferences; 
/* ---------------------------------------------------------------------------------------*/
         
   TASK-KNOWLEDGE diagnosis-tasks;
      TASK diagnosis-task;
          DOMAIN-NAME:diagnosis-car-application;
          ROLES:
              INPUT:
                  complaint:"Find ....";
              OUTPUT:
                  faults:"the faults .....";
                  evidence:"sdfsdfsdf ....";
      END TASK diagnosis-task;
     
      TASK-METHOD diagnosis-method;
          REALIZES:diagnosis-task;
          DECOMPOSITION:
              INFERENCES:cover,select,specify,verify;
              TRANSFER-FUNCTIONS:obtain;
          ROLES:
              INTERMEDIATE:
                  differential:"asdd";
                  hypothesis:"df";
                  result:"ff";
                  expected-finding:"sd";
                  actual-finding:"sdf";
          CONTROL-STRUCTURE:
              WHILE NEW-SOLUTION cover(complaint -> hypothesis) DO
                  differential := hypothesis ADD differential;
              END WHILE
              REPEAT
                  select(differential -> hypothesis);
                  specify(hypothesis -> observable);
                  obtain(observable -> finding);
                  evidence := finding ADD evidence;
                  FOR-EACH hypothesis IN differential DO
                     verify(hypothesis + evidence -> result);
                     IF result == false
                         THEN differential := differential SUBTRACT hypothesis;
                     END IF
                 END FOR-EACH
              UNTIL
                  SIZE differential =< 1 or "no more observables left"
             END REPEAT
             faults := differential;
      END TASK-METHOD diagnosis-method;
     
      TASK select-subtask;
          DOMAIN-NAME:select-car-application;
          ROLES:
              INPUT:
              OUTPUT:
      END TASK select-subtask;
     
      TASK-METHOD select-method;
      END TASK-MOTHOD select-method;

   END TASK-KNOWLEDGE diagnosis-tasks;
/* ---------------------------------------------------------------------------------------*/

  
END KNOWLEDGE-MODEL Diagnosis;