//건축물의 구조기준 등에 관한 규칙 24조 (건축물의 규모제한) 1항
Check(RSSB_24_1){
        getResult(RSSB_3_3) = TRUE AND IF CS THEN KS
}
CS{
     isObjectProperty(CompressionMember.isStructuralMember) = TURE
     getObjectMaterial(CompressionMember) = "Timber"
}
KS{
     getObjectSectionalArea(CompressionMember) >= 4500mm2
}


//건축물의 구조기준 등에 관한 규칙 24조 (압축재의 최소단면 및 모서리에 설치하는 기둥) 2항

Check(RSSB_24_2){

        getResult(RSSB_3_3) = TRUE AND IF CS THEN KS

}

CS{

     getBuildingStoriesCount() >= 2

}

KS{

     Column myColumn{

     isInstalled(Column, Building.Edge) = TRUE

//건축물의 구조기준 등에 관한 규칙 25조 (가새) 1항
Check(RSSB_25_1){
        getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     Brace myBrace{
     isObjectProperty(Brace.isTensileBrance) = TRUE
     }
     isObjectProperty(Brace.depth) >= 15mm
     getObjectMaterial(Brace) = "Timber"
     isObjectProperty(Brace.Material.width) >= 90mm
}


//건축물의 구조기준 등에 관한 규칙 25조 (가새) 2항

Check(RSSB_25_2){

        getResult(RSSB_3_3) = TRUE AND KS

}

KS{

     Brace myBrace{

     isObjectProperty(Brace.isCompressionBrace) = TRUE

     }

     Column myColumn{

     isObjectProperty(Column.isFramedColumn) = TRUE

     }

     CW = getObjectProperty(myColumn.width) * 1/3



     getObjectProperty(Brace.depth) >= 35mm

     getObjectMaterial(Brace) = "Timber"

     getObjectProperty(Brace.Material.width) = CW

}


//건축물의 구조기준 등에 관한 규칙 25조 (가새) 3항

Check(RSSB_25_3){

        KS

}

KS{

     isObjectProperty(HorizontalMember.isStructuralMember) = TRUE

     isConnectedTo(Brace, HorizontalMember) = TRUE

}

//건축물의 구조기준 등에 관한 규칙 28조 (적용범위 등) 1항
Check(RSSB_28_1){
     getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     (getObjectProperty(Building.Structure.materialType) = "Brick" OR "Stone" OR "ConcreteBlock")
     OR (isObjectProperty(Building.Structure.isMansoryStructure) = TRUE
     getObjectProperty(Building.Structure.materialType) != "SteelReinforcedConcreteBlock")
}


//건축물의 구조기준 등에 관한 규칙 28조 (적용범위 등) 2항
Check(RSSB_28_2){
     getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     getBuildingHeight() <= 4m
     getGrossFloorArea() <= 20m2
}


//건축물의 구조기준 등에 관한 규칙 28조 (적용범위 등) 3항
Check(RSSB_28_3){
     getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     Wall myWall{
     isObjectProperty(Wall.isStructuralMember) = FALSE
     isObjectProperty(Wall.isPartitionWall) = TRUE
     isObjectProperty(Wall.Structure.isMansoryStructure) = TRUE
     }
     getObjectHeight(myWall) <= 2m
}

//건축물의 구조기준 등에 관한 규칙 3조 (적용범위 등) 3항

Check(RSSB_3_3){

     KS

}



KS{

     getResult(EDBA_32_1) = FALSE 

     isObjectProperty(Building.isSmallBuilding) = TRUE

}

//건축물의 구조기준 등에 관한 규칙 30조 (기초) 1항
Check(RSSB_30_1){
        getResult(RSSB_28_3) = TRUE AND getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     Wall myWall{
     isObjectProperty(Wall.isLoadBearingWall) = TRUE
     getObjectProperty(Wall.Structure.isMansoryStructure) = TRUE
     }
     Foundation myFoundation{
     isInstalled(myWall, Foundation) = TRUE
     }
     isObjectProperty(myFoundation.isContinuousFoundation) = TRUE
}


//건축물의 구조기준 등에 관한 규칙 30조 (기초) 2항

Check(RSSB_30_2){

        getResult(RSSB_28_3) = TRUE AND getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS

}

CS{

     getResult(RSSB_30_1) = TRUE

}

KS{

     Wall myWall{

     isObjectProperty(Wall.isFoundationWall) = TRUE

     }

     (getObjectProperty(FoundationPlate.Structure.materialType) = "ReinforcedConcrete"

     OR getObjectProperty(FoundationPlate.Structure.materialType) = "PlainConcrete")

     getObjectProperty(myWall.depth) >= 250mm

}

//건축물의 구조기준 등에 관한 규칙 31조 (내력벽의 높이 및 길이) 1항
Check(RSSB_31_1){
        getResult(RSSB_28_1) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS
}
CS{
     isObjectProperty(Building.Structure.isMansoryStructure) = TRUE
     getBuildingStoriesCount() = 2
}
KS{
     Wall myWall{
     isObjectProperty(Wall.isLoadBearingWall) = TRUE
     getFloorNumber(Wall.Floor) = TRUE
     }
     getObjectHeight(myWall) < 4m
}


//건축물의 구조기준 등에 관한 규칙 31조 (내력벽의 높이 및 길이) 2항
Check(RSSB_31_2){
        getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS
}
     Wall myWall{
     isObjectProperty(Wall.isLoadBearingWall) = TRUE
     }
CS{     
     isObjectProperty(myWall.Structure.isMansoryStructure) = TRUE
}
KS{
     getObjectLength(myWall) < 10m
}


//건축물의 구조기준 등에 관한 규칙 31조 (내력벽의 높이 및 길이) 3항
Check(RSSB_31_3){
        getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     Wall myWall{
     isObjectProperty(Wall.isLoadBearingWall) = TRUE
     isObjectProperty(myWall.Structure.isMansoryStructure) = TRUE
     }
     Space mySapce{
     isSurrounded(Space, myWall) = TRUE
     }
     getFloorArea(mySpace) < 80m2
}

//건축물의 구조기준 등에 관한 규칙 32조 (내력벽의 두께) 1항
Check(RSSB_32_1){
        getResult(RSSB_32_7) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}
KS{
     Wall myWall1{
     isObjectProperty(Wall.isLoadBearingWall) = TRUE
     isObjectProperty(myWall.Structure.isMansoryStructure) = TRUE
     }
     Floor myFloor{
     isInstalled(myWall1, Floor) = TRUE
     }
     Wall myWAll2{
     isInstalled(Wall, myFloor.UpperFloor) = TRUE
     }
     WD = getObjectProperty(myWall2.depth)

     getObjectProperty(myWall1.depth) >= WD
}


//건축물의 구조기준 등에 관한 규칙 32조 (내력벽의 두께) 2항



Check(RSSB_32_2){

        getResult(RSSB_32_7) = TRUE AND getResult(RSSB_32_3) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN  KS

}

CS {

   getResult(RSSB_33_3)=True

}





KS{

     //HW means Height of wall

Wall myWall{
isObjectProperty(Wall.isLoadBearingWall) = TRUE
}
       HW=getObjectHeight(myWall)



     IF isObjectProperty(Wall.Structure.isMansoryStructure)=TRUE

 

    

         IF getBuildingHeight()<5 m

            IF getFloorNumber(myWall)=1

                 IF getObjectLength(myWall)<8 m

                     THEN getObjectThickness(myWall)>= 150 mm

                 ELSE THEN  getObjectThickness(myWall)>= 190 mm   

                 END IF 

            END IF 



         ELSE IF  getBuildingHeight()>=5 m  

                  getBuildingHeight()<11 m

                  getFloorNumber(myWall)=1

                  OR getFloorNumber(myWall)=2

             THEN getObjectThickness(myWall)>= 190 mm

         



         ELSE IF  getBuildingHeight()>=11 m  

                  IF getObjectLength(myWall)<8 m

                      getFloorNumber(myWall)=1

                      OR getFloorNumber(myWall)=2

                             THEN getObjectThickness(myWall)>=190 mm

                  ELSE IF getFloorNumber(myWall)=1

                               THEN getObjectThickness(myWall)>=290 mm

                  ELSE IF  getFloorNumber(myWall)=2

                               THEN getObjectThickness(myWall)>=190 mm

                  END IF          

        END IF





             IF getObjectMaterial(myWall)="벽돌"

                  THEN getObjectThickness(myWall)>= HW/20



             ELSE IF getObjectMaterial(myWall)="Block"

                  THEN getObjectThickness(myWall)>= HW/16

              

             END IF







    END IF 

}


//건축물의 구조기준 등에 관한 규칙 32조 (적용범위 등) 3항

Check(RSSB_32_3){

     getResult(RSSB_32_7) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CH TEHN KS

}

     Wall myWall{

          isObjectProperty(Wall.isLoadBearingWall) = TRUE

     }

     Wall myWall1{

          getResult(RSSB_32_2) = TRUE

     }

CS{

     getObjectProperty(myWall.Structure.materialType) = "Stone" OR "Brick" OR "ConcreteBlock" OR "SteelReinforcedConcreteBlock"

}

KS{

     WT = getWallThickness(myWall)

     WT >= 1.2* getWallThinkness(myWall1)

     WT >= 1/15*getObjectHeight(myWall)

}


// 건축물의 구조기준 등에 관한 규칙 32조 (내력벽의 두께) 4항

Check(RSSB_32_4){
      getResult(RSSB_32_7) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS 
}

CS{
   getResult(RSSB_33_3)=True
}

KS{

}


//  건축물의 구조기준 등에 관한 규칙 32조 (내력벽의 두께) 7항
Check(RSSB_32_7){
     KS
}

KS{
 isObjectProperty(Wall.Structure.isMansoryStructure) = TRUE
 isObjectProperty(Wall.isDoubleWall) = TRUE
}

check(RSSB_33_1){
getResult(RSSB_28_3) = TRUE AND 
(RSSB_28_1) = TRUE AND 
getResult(RSSB_3_3) = TRUE
     Wall myWall{
          getObjectStructure(Wall) = "MansonryStructure"
          getObjectType(Wall) = "PartitionWall"
     }

     getObjectThickness(myWall) >= 90mm
}


// 건축물의 구조기준 등에 관한 규칙 33조 (칸막이벽 등의 두께) 2항 



Check(RSSB_33_2){

      getResult(RSSB_28_3) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF (!CS1 AND CS2) THEN KS

}





Wall myWall{

         isObjectProperty(Wall.isPartitionWall)=True

         isObjectProperty(Wall.Structure.isMansoryStructure)=True

    }



CS1{

      getResult(RSSB_34)=True

}





CS2{

    FN=getFloorNumber(myWall)  //FN means myWall's floor number 

    Floor myFloor{

          Floor.number=FN+1

    }

    isInstalled(myFloor, myWall)= True

    OR isInstalled (myFloor, MainStructure)=True

}



KS{

     getObjectThickness(myWall)>=190 mm 

}


//건축물의 구조기준 등에 관한 규칙 33조 (칸막이벽 등의 두께) 3항 

Check(RSSB_33_3){
      getResult(RSSB_28_3) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}

KS{
      isObjectProperty(Wall.isPartitionWall)=True
      isObjectProperty(Wall.Structure.isMansoryStructure)=True
}

//건축물의 구조기준 등에 관한 규칙 34조 (테두리보)



Check(RSSB_34){

     getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN  KS

}



CS{

    Wall myWall{

      isObjectProperty(Wall.isLoadBearingWall)=True

    }



    isObjectProperty(myWall.Structure.isMansoryStructure)= True

}

   



KS{

  

    WD=getObjectProperty(myWall.depth)

    WH=getObjectProperty(myWall.height)

    WallGirder  myWallGirder{   

      getObjectProperty(WallGirder.height)>=1.5*WD

    }

   

    isInstalled(myWallGrider, myWall, Top)=True







   IF getBuildingStoriesCount()=1

     (WD>=WH/16

      OR getObjectProperty(myWall.length)<=5 m

      )

   THEN getObjectProperty(myWallGrider.Structure.materialType)="Timber"

   

   ELSE THEN   getObjectProperty(myWallGrider.Structure.materialType)="SteelFrame"

OR getObjectProperty(myWallGrider.Structure.materialType)="ReinforcedConcrete"



   END IF

}

//건축물의 구조기준 등에 관한 규칙 35조 (개구부) 1항
Check(RSSB_35_1){
        getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS
}
CS{
     Wall myWall1{
     isObjectProperty(myWall.Structure.isMansoryStructure) = TRUE
     }
     isInstalled(Window, myWall) = TRUE
     OR isInstalled(Door, myWall) = TRUE
     OR isInstalled(Opening, myWall) = TRUE
}
KS{
     getResult(RSSB_35_1_1) = TRUE
     getResult(RSSB_35_1_2) = TRUE
}


//건축물의 구조기준 등에 관한 규칙 35조 (개구부) 1항 1호
Check(RSSB_35_1_1){
        KS
}
KS{
     Wall myWall1{
     isObjectProperty(Wall.isRightAngleCrossingWall) = TRUE
     isInstalled(Wall, Floor.One) = TRUE
     }
     Wall myWall2{
     isPartitioned(Wall, , myWall1) = TRUE
     }
     WL = getObjectWidth(myWall2)
     OW = getObjectWidth(myOpening)
     Opening myOpening{
     isInstalled(Opening, Wall) = TRUE
     }
     Sum(OW) <= WL * 1/2
}


//건축물의 구조기준 등에 관한 규칙 35조 (개구부) 1항 2호
Check(RSSB_35_1_2){
     KS2 AND IF CS THEN KS1
}
KS2{
     Opening myOpening1{
     isInstalled(Opening, Floor.One) = TRUE
     }
     Opening myOpening2{
     isInstalled(Opening, myOpening1.Floor.UpperFloor) = TRUE
     }
     getObjectVerticalDistance(myOpening1, myOpening2) >= 600mm
}
CS{
     Opening myOpening3{
     isInstalled(Opening, Floor.One.Wall.One) = TRUE
     }
     getObjectInterval(myOpening3,,a) >= 600mm
}


//건축물의 구조기준 등에 관한 규칙 35조 (개구부) 2항
Check(RSSB_35_2){
     getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF (!CS1 AND CS2) THEN KS
}
     Wall myWall1{
     isObjectProperty(myWall.Structure.isMansoryStructure) = TRUE
     }
CS1{
     isObjectProperty(Opening.UpperSideShape) = "Arc"
}
CS2{
     isInstalled(Opening, myWall1) = TRUE
}
KS{
     Wall myWall2{
     isObejctProperty(Wall.isRightAngleCrossingWall) = TRUE
     isInstalled(Wall, myWall1.Floor) = TRUE
     }
     WD = getObjectProperty(myWall1.depth)
     getObject(Floor.One.Opening)
     (getObjectInterval(Opening, ) >= 2* WD
     OR getObjectDistance(Opening, myWall2.Center) >= 2* WD
}


//건축물의 구조기준 등에 관한 규칙 35조 (개구부) 3항

Check(RSSB_35_3){

     getResult(RSSB_28_3) = TRUE AND getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS

}

CS{

     getObjectProperty(Opening.width) > 1.8m

}

KS{

     Beam myBeam{

     isOjectProperty(Beam.isLintel) = TRUE

     getObjectProperty(Beam.Structure.materialType) = "ReinforcedConcrete"

      }



     getObjectVerticalLocation(myBeam, Opening) > 0

}

//건축물의 구조기준 등에 관한 규칙 36조 (벽의 홈)



Check(RSSB_36){

   getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS 

}



CS{

   Wall myWall{

     isObjectProperty(Wall.Structure.isMansoryStructure)=True

   }

   

   isInstalled(Channel, myWall)=True

   

}

   

KS{

   WD=getObjectProperty(myWall.depth)



   IF getObjectProperty(Channel.shapeType)="VerticleChannel"

      FH=getObjectHeight(Floor.Space)

      getObjectProperty(Channel.length)>=FH*3/4

   

   THEN getObjectProperty(Channel.depth)<= WD/3



   ELSE IF getObjectProperty(Channel.shapeType)="HorizontalChannel"

  

   THEN getObjectProperty(Channel.depth)<= WD/3

        getObjectProperty(Channel.length)<= 3 m



   END IF 

}

//건축물의 구조기준 등에 관한 규칙 39조 (조적식구조인 담) 
Check(RSSB_39){
     getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS
}
CS{
     isObjectProperty(Fence.Structure.isMansoryStructure) = TRUE
}
KS{
     getResult(RSSB_39_1) = TRUE
     getResult(RSSB_39_2) = TRUE
     getResult(RSSB_39_3) = TRUE
}


//건축물의 구조기준 등에 관한 규칙 39조 (조적식구조인 담) 1호
Check(RSSB_39_0_1){
     KS
}
KS{
     getObjectHeight(Fence) <= 3m
}


//건축물의 구조기준 등에 관한 규칙 39조 (조적식구조인 담) 2호
Check(RSSB_39_0_2){
     KS2 AND IF CS THEN KS1
}
KS2{
     isObjectProperty(Fence.depth) >= 190mm
}
CS{
     getObjectHeight(Fence) <= 2m
}
KS1{
     isObjectProperty(Fence.depth) >= 90mm
}


//건축물의 구조기준 등에 관한 규칙 39조 (조적식구조인 담) 3호
Check(RSSB_39_0_3){
     IF !CS THEN KS
}
CS{
     
}
KS{
     FD = getObjectProperty(Fence.depth)
     Wall myWall{
     isObjectProperty(Wall.isSupportingWall) = TRUE
     }
     (isInstalled(myWall, Fence, b, 2) = TRUE
     getObjectProperty(Wall.depth) >= FD)
     OR (isInstalled(myWall, Fence, b, 4) = TRUE
     getObjectProperty(Wall.depth) >= 1.5* 2호 규정에 의한 담의 두께)
}

//건축물의 구조기준 등에 관한 규칙 41조 (적용범위 등) 1항
Check(RSSB_41_1){
     getResult(RSSB_41_1) = TRUE AND KS
}
KS{
     getObjectProperty(Building.Structure.materialType) = "SteelReinforcedConcreteBlock" 
     OR "ReinforcedConcrete"
}


//건축물의 구조기준 등에 관한 규칙 41조 (적용범위) 2항

Check(RSSB_41_2){
     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS 
}

CS{
    getBuildingHeight()<=4 m
    getGrossFloorArea() <=20 m2  
}

KS{

   getResult(RSSB_42)=True
   getResult(RSSB_45)=True
}

//     건축물의 구조기준 등에 관한 규칙 42조 (기초)
Check(RSSB_42){
     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}

KS{
     Wall myWall{
          isObjectProperty(Wall.isLoadBearingWall) = TRUE
          getFloorNumber(Wall) < 1
     }

     getObjectProperty(myWall.Structure.materialType) = "SteelReinforcedConcreteBlock"
     isObjectProperty(Foundation.isCountinuousFoundation) = TRUE

     getObjectStructure(FoundationPlate.Structure.materialType) = "ReinforcedConcrete"
}

//     건축물의 구조기준 등에 관한 규칙 43조 (내력벽) 1항
Check(RSSB_43_1){
     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}

KS{
    Wall myWall{
      isObjectProperty(Wall.isLoadBearingWall) = TRUE
      getObjectProperty(Wall.Structure.materialType) = "SteelReinforcedConcreteBlock"
    }
  
        FA =getObjectArea(Floor.One)
     getObjectProperty(myWall.Length)>= FA*0.15 m
        getObjectProperty(myWall.width)>= FA*0.15 m

        Space mySpace{
            isSurrounded(Space, myWall)=True
        }

         getFloorArea(mySpace)<=80 m2
}


//     건축물의 구조기준 등에 관한 규칙 43조 (내력벽) 2항
Check(RSSB_43_2){
     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}

KS{
     Wall myWall{
          isObjectProperty(Wall.isLoadBearingWall) = TRUE
          getFloorNumber(Wall) < 1
          getObjectProperty(Wall.Structure.materialType) = "SteelReinforcedConcreteBlock"
     }

     getWallThickness(myWall) >= 150mm
}


//     건축물의 구조기준 등에 관한 규칙 43조 (내력벽) 3항
Check(RSSB_43_3){
     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}

KS{
    Wall myWall{
      isObjectProperty(Wall.isLoadBearingWall) = TRUE
      getObjectProperty(Wall.Structure.materialType) = "SteelReinforcedConcreteBlock"
    }

   Reinforcement myReinforcement{
        getObjectProperty(Reinforcement.diameter)>=12 mm
   }
      
    isInstalled( myReinforcement, myWall, Vertical , myWall.BothEndSides)=True
    isInstalled( myReinforcement, myWall, Vertical , myWall.Edge)=True

    Reinforcement myReinforcement2{
        getObjectProperty(Reinforcement.diameter)>=9 mm
   }
   
    isInstalled( myReinforcement2, myWall, 800 mm , myWall.BothEndSides)=True
    isInstalled( myReinforcement2, myWall, 800 mm , myWall.Edge)=True
}


//건축물의 구조기준 등에 관한 규칙 43조 (내력벽) 4항

Check(RSSB_43_4){

     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS

}



KS{

   RD>=40*getObjectProperty(RSSB_43_3_myReinforcement.diameter)

      

    isInstalled( RSSB_43_3_myReinforcement.BothEndSides, FoundationPlate , RD, "정착")=True



    OR  isInstalled( RSSB_43_3_myReinforcement.BothEndSides, WallGirder, RD, "정착")=True



      OR  isInstalled( RSSB_43_3_myReinforcement.BothEndSides, FloorSlab   , RD, "정착")=True



}

//건축물의 구조기준 등에 관한 규칙 44조 (테두리보)



Check(RSSB_44){

     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF !CS THEN  KS

}



!CS{

  Wall myWall{

   isInstalled(Wall, TopFloor)=True

  } 

  

  FloorSlab myFloorSlab{
isInstalled(FloorSlab, Rooftop) = TRUE
       getObjectProperty(FloorSlab.Structure.materialType)="ReinforcedConcrete"

  }

   isInstalled(myFloorSlabOfRooftop, myWall, Top)=True   

    } 



KS{

   Wall myWall{

     isObjectProperty(Wall.isLoadBearingWall)=True

     isObjectProperty(Wall.Structure.isMansoryStructure)= True

   }



   WD=getObjectProperty(myWall.depth)

   

   WallGirder myWallGirder{   

     getObjectProperty(WallGirder.height)>=1.5*WD

     getObjectProperty(myWallGrider.Structure.materialType)="ReinforcedConcrete"

   }

   

    isInstalled(myWallGrider, myWall, Top)=True



  

}

//     건축물의 구조기준 등에 관한 규칙 45조 (보강블록구조의 담)
Check(RSSB_45){
     getResult(RSSB_41_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND KS
}

KS{
     getResult(RSSB_45_0_1) = TRUE
     getResult(RSSB_45_0_2) = TRUE
     getResult(RSSB_45_0_3) = TRUE
}


//     건축물의 구조기준 등에 관한 규칙 45조 (보강블록구조의 담) 1항
Check(RSSB_45_1){
     getResult(RSSB_3_3) = TRUE AND KS
}

KS{
     getObjectHeight(Fence) <= 3m
}


//     건축물의 구조기준 등에 관한 규칙 45조 (보강블록구조의 담) 2항
Check(RSSB_45_2){
     getResult(RSSB_3_3) = TRUE AND IF (CS THEN KS1) OR (!CS THEN KS2)
}

CS{
     getObjectHeight(Fence) > 2m
}

KS1{
     getObjectThickness(Fence) >= 150mm
}

KS2{
     getObjectThickness(Fence) >= 90mm
}


//     건축물의 구조기준 등에 관한 규칙 45조 (내력벽) 4호
Check(RSSB_45_0_4){
     getResult(RSSB_3_3) = TRUE AND KS
}

KS{
  
    isInstalled( Reinforcement, Fense, 800 mm , Fense.In)=True

    Reinforcement myReinforcement{
        getObjectProperty(Reinforcement.diameter)>=9 mm
   }

     isInstalled( myReinforcement, Fense, Vertical , Fense.BothEndSides)=True
     isInstalled( myReinforcement, Fense, Vertical , Fense.Edge)=True
}

//건축물의 구조기준 등에 관한 규칙 47조 (적용범위) 2항



Check(RSSB_47_2){

     getResult(RSSB_3_3) = TRUE AND IF CS THEN KS 

}



CS{

    getBuildingHeight()<=4 m

    getGrossFloorArea() <=30 m2  



    OR getObjectHeight(Fence)<= 3m

}



KS{



   getResult(RSSB_51)=True

}

//건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 

Check(RSSB_51){
     getResult(RSSB_3_3) = TRUE AND IF CS THEN KS 
}

CS{
   // 철근을 덥는 콘크리트 
}

KS{
   getResult(RSSB_51_0_1)=True
   getResult(RSSB_51_0_2)=True

}


//건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 1호

Check(RSSB_51_0_1){
         IF CS THEN KS 
}

CS{
    isExternal(Concrete)=True
   // 흙에 접하거나 
}

KS{
   getResult(RSSB_51_0_1_가)=True
   getResult(RSSB_51_0_1_나)=True
   getResult(RSSB_51_0_1_다)=True
   
}



//건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 1호 가목

Check(RSSB_51_0_1_가){
      IF CS THEN KS
}

CS{
    getObjectDiameter("철근")>=29 mm 
}

KS{
   getObjectThickness("철근을 덮는 콘크리트")>=60 mm
}


// 건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 1호 나목

Check(RSSB_51_0_1_나){
     IF CS THEN KS
}

CS{
   getObjectDiameter("철근")>16 mm
   getObjectDiameter("철근")<29 mm  
}

KS{
   getObjectThickness("철근을 덮는 콘크리트")>=50 mm
}




// 건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 1호 다목

Check(RSSB_51_0_1_다){
     IF CS THEN KS
}

CS{   
       getObjectDiameter("철근")<=16 mm 
}

KS{
   getObjectThickness("철근을 덮는 콘크리트")>=40 mm
}


//건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 2호

Check(RSSB_51_0_2){
         IF CS THEN KS 
}

CS{
    isExternal(Concrete)=False
   // 흙에 접하지 않는 경우 
}

KS{
   getResult(RSSB_51_0_2_가)=True
   getResult(RSSB_51_0_2_나)=True
}



// 건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 2호 가목

Check(RSSB_51_0_2_가){
        KS
}

KS{
       getObjectThickness(Slab)>=20 mm
       getObjectThickness(Wall)>=20 mm
       getObjectThickness(BridgingJoist)>=20 mm
}


// 건축물의 구조기준 등에 관한 규칙 51조 (철근을 덮는 두께) 2호 나목

Check(RSSB_51_0_2_나){
        KS
}

KS{
       getObjectThickness(Beam)>=40 mm
       getObjectThickness(Column)>=40 mm
      
}

//건축물의 구조기준 등에 관한 규칙 52조 (보의 구조) 



Check(RSSB_52){

     getResult(RSSB_3_3) = TRUE AND IF CS THEN KS

}



CS{

    isObjectProperty(Beam.isStructuralMember)=True

}



KS{

    getObjectProperty(Beam.MainReinforcement.diameter)>=12 mm

    getObjectProperty(Beam."늑근".diameter

//건축물의 구조기준 등에 관한 규칙 53조 (콘크리트슬래브의 구조) 

Check(RSSB_53){
         getResult(RSSB_3_3) = TRUE AND KS
}

KS{
    getResult(RSSB_53_0_1)=True
    getResult(RSSB_53_0_2)=True
}


// 건축물의 구조기준 등에 관한 규칙 53조 (콘크리트슬래브의 구조) 1호



Check(RSSB_53_0_1){

       KS

}



KS{

isObjectProperty(Slab.isConcreteSlab) = TRUE

     getObjectThickness(Slab)>= 80 mm

     getResult(RSSB_*_9)=True 

}


//건축물의 구조기준 등에 관한 규칙 53조 (콘크리트슬래브의 구조) 2호

Check(RSSB_53_0_2){
        KS
}

KS{
   getObjectDistance(TensionReinforcement, "최대휨모멘트를 받는 부분의 단변방향의 간격") <=200 mm
   getObjectDistance(TensionReinforcement, "최대휨모멘트를 받는 부분의 장변방향의 간격") <=300 mm

    TS=getObjectThickness(Slab)
    getObjectDistance(TensionReinforcement, "최대휨모멘트를 받는 부분의간격") <= TS/3


}

//건축물의 구조기준 등에 관한 규칙 54조 (내력벽의 구조)

Check(RSSB_54){
   getResult(RSSB_3_3) = TRUE AND IF CS THEN KS 
}

CS{
    isObjectProperty(Wall.isStructuralMember)=True
    getObjectProperty(Wall.material)="Concrete"
}

KS{
    getResult(RSSB_54_0_1)=True
    getResult(RSSB_54_0_2)=True
}


//건축물의 구조기준 등에 관한 규칙 54조 (내력벽의 구조) 1호

Check(RSSB_54_0_1){
      IF !CS THEN KS
}

Wall myWall{
     isObjectProperty(Wall.isLoadBearingWall)=True
  }

CS{
    getWallThickness(myWall)>=120 mmm
}

KS{

  
   H1=getObjectHeight(myWall)
   H2= H1-4.5 m
   getWallThickness(myWall,H2,H1)>=150 mm
  
   H3=getFloorElevationHeight(myWall.Floor)
   

   getWallThickness(myWall,H3,H2,3 m, a)>=150+10*a
   

  
}


//건축물의 구조기준 등에 관한 규칙 54조 (내력벽의 구조) 2호

Check(RSSB_54_02){
      KS
}

KS{
   Wall myWall{
     isObjectProperty(Wall.isLoadBearingWall)=True
  }

  Reinforcement myReinforcement{
       getObjectProperty(Reinforcement.diameter)>=9 mm
  }
  
  isInstalled(myReinforcement, myWall, 450 mm)=True
  //벽두께의 3배 이하이어야 한다. 
  IF getObjectProperty(myWall.depth)>=200 mm
  THEN isInstalled(DoubleReinforcement, myWall, myWall.BothSides)=True
  END IF 

}

//건축물의 구조기준 등에 관한 규칙 9조의3 (건축물의 규모제한) 1항

Check(RSSB_9-3_1){

        IF (CS1 THEN KS1) OR (CS2 THEN KS2)

}

     MainStructuralPart myMainStructuralPart1{
     getObject(FloorSlab) OR getObject(RoofTruss)
     }
MainStructuralPart myMainStructuralPart2{
     MainStructuralPart != myMainStructuralPart1
     }

CS1{

     isInstalled(SprinklerSystem) != TRUE

     getObjectProperty(myMainStructuralPart2.Structure.materialType) = "Timber"

}

KS1{

     getObjectVerticalDistance(FloorSlab, Roof) <= 18m

     getObjectVerticalDistance(FloorSlab, Eave) <= 15m

     getGrossFloorArea() <= 3000m2

}

CS2{

     isInstalled(SprinklerSystem) = TRUE

     getObjectProperty(myMainStructuralPart2.Structure.materialType) = "Timber"

}

KS1{

     getObjectVerticalDistance(FloorSlab, Roof) <= 18m

     getObjectVerticalDistance(FloorSlab, Eave) <= 15m

     getGrossFloorArea() <= 6000m2

}


//건축물의 구조기준 등에 관한 규칙 9조의3 (건축물의 규모제한) 2항
Check(RSSB_9-3_2){
        IF CS THEN KS
}
CS{
     isObjectProperty(MainStructuralPart.Structure.isUnreinforcedMansoryStructure) = TRUE
}
KS{
     getObjectVerticalDistance(FloorSlab, Roof) <= 15m
     getObjectVerticalDistance(FloorSlab, Eave) <= 11m     
     getBuildingStoriesCount() <= 3
}

//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 
Check(RFB_10){
     getResult(RFB_10_2) = TRUE
     getResult(RFB_10_3) = TRUE
}



//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 
Check(RFB_10_0_2){

     getResult(RFB_10_0_2_가) = TRUE

     getResult(RFB_10_0_2_나) = TRUE

     getResult(RFB_10_0_2_다) = TRUE

     getResult(RFB_10_0_2_라) = TRUE

     getResult(RFB_10_0_2_바) = TRUE

     getResult(RFB_10_0_2_사) = TRUE

}


//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 2호 가목
Check(RFB_10_0_2_가){
}

KS{
isPartitioned(, obj2, obj3) 
}
}


//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 2호 나목
Check(RFB_10_0_2_나){
     KS1 AND IF !(CS) THEN KS2
}
     Space mySpace{
     hasObject(Floor,Space)=TRUE
     isAccessible(Platform,Space) = TRUE
     }
KS1{
     isExist(mySpace)=TRUE
}
CS{
     isAccessible(Platform, myFloor) = TRUE
}
KS2{
     Door myDoor{
          hasSpace(Platform, Door) =TRUE
          hasSpace(mySpace, Door) =TRUE
          Door != ElevatorShaft.Opening
     }
     isObjectProperty(myDoor.isStrictFireproofDoor)= TRUE
}



//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 2호 다목
Check(RFB_10_0_2_다){
     KS
}
KS{
     Elevator myElevator{
          isObjectProperty(Elevator.isEmergency)=TRUE
     }
     Window myWindow{
          isObjectProperty(Window.isExternalDirection)=TRUE
     }
     SmokeExhaustionSystem mySmokeExhaustionSystem{
          getResult(RFB_14_2) = TRUE
     }
     hasObject(myElevator.Platform,OpenFloorStructure) = TRUE
     hasObject(myElevator.Platform, myWindow) = TRUE
     isExist(mySmokeExhaustionSystem)=TRUE
     }


//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 2호 라목
Check(RFB_10_0_2_라){
     KS
}

KS{
     Elevator myElevator{
          isObjectProperty(Elevator.isEmergency)=TRUE
     }
     isObjectProperty(myElevator.Platform.Wall.InteriorFinish.Material.nonCombustibility) = TRUE
     isObjectProperty(myElevator.Platform.CeilingCovering.InteriorFinish.Material.nonCombustibility) = TRUE
}


//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 2호 바목
Check(RFB_10_0_2_바){
     IF !CS THEN KS
}

     Elevator myElevator{
          isObjectProperty(Elevator.isEmergency)=TRUE
     }

CS{
     isExternal(myElevator.Platform) = TRUE
}
KS{
     EN = getObjectProperty(Elevator.numberOf)
     getObjectProperty(myElevator.Platform.area) >= EN*6
}


//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 3호

Check(RFB_10_0_3){

     getResult(RFB_10_0_3_가) = TRUE

     getResult(RFB_10_0_3_나) = TRUE

}


//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 3호 가목
Check(RFB_10_0_3_가){
     KS
}
KS{
     Elevator myElevator{
          isObjectProperty(Elevator.isEmergency)=TRUE
     }

     isObjectProperty(myElevator.ElevatorShaft.isFirePartition)=TRUE
}



//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 3호 나목

Check(RFB_10_0_3_나){

     KS

}



KS{

     Floor myFloor{

          isObjectProperty(Floor.isEscape)=TRUE

     }
ElevatorShaft myElevatorShaft1{
     hasObject(Floor,ElevatorShaft)=TRUE
}
ElevatorShaft myElevatorShaft2{
     hasObject(myFloor,ElevatorShaft)=TRUE     
}
     isConnectedTo(myElevatorShaf1t, myElevatorShaft2, SingleStructure)=TRUE

}

//     건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항
Check(RFB_13_1){
     IF CS THEN KS
}

CS{
     getBuildingUsage() = "DetachedHouse"
     OR getBuildingUsage() = "MultiUnitHouse"
}

KS{
     getResult(RFB_13_1_1) = TRUE
     getResult(RFB_13_1_2) = TRUE
     getResult(RFB_13_1_5) = TRUE
     getResult(RFB_13_1_6) = TRUE
     getResult(RFB_13_1_7) = TRUE
}


//     건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 1호
Check(RFB_13_1_1){
     KS
}

KS{
     hasSpace(Room, Boiler) = FALSE
     
     Room myRoom{
          hasSpace(Room, Boiler) = TRUE
     }

     Room myRoom2{
          hasAdjacent(myRoom, Room) = TRUE
     }

     Wall myWall{
          isPartitioned(myRoom, myRoom2, Wall) = TRUE
          hasObject(Wall, Door.isEntrance) = FALSE
          isObjectProperty(Wall.isfireResistantStructure) = TRUE
     }

     isExist(myWall) = TRUE
}


//     건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 2호

Check(RFB_13_1_2){

     IF CS THEN KS

}



CS{

     isExist(Boiler) = TRUE
isObjectProperty(Boiler.isElectricBoiler) = FALSE
}



KS{

     Ventilator myVentilator{

          getObjectArea(Ventilator) >= 0.5cm2

     }


Space mySpace{
getSpaceUsage(Space) = "BoilerRoom"  
}
     isInstalled(myVentilator, mySpace, a, top) = TRUE



     AirInlet myAirInlet{

          getObjectDiameter(AirInlet, b) >= 10cm

     }



     AirOutlet myAirOutlet{

          getObjectDiameter(AirOutlet, b) >= 10cm

     }



     (isInstalled(myAirInlet, mySpace, a, top) = TRUE

     OR isInstalled(myAirOutlet, mySpace, a, top) = TRUE)



     (isInstalled(myAirInlet, mySpace, a, bottom) = TRUE

     OR isInstalled(myAirOutlet, mySpace, a, bottom) = TRUE)

}


//     건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 5호

Check(RFB_13_1_5){

     IF CS THEN KS

}



CS{
isObjectProperty(Boiler.isOilBoiler) = FALSE

}



KS{
Space mySpace1{
getSpaceUsage(Space) = "BoilerRoom"  
}

Space mySpace2{
getSpaceUsage(Space) = "OilStorageFacilities"
}
     hasSpace(mySpace1, mySpace2) = FALSE

}


//     건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 6호

Check(RFB_13_1_6){

     IF CS THEN KS

}



CS{

     getBuildingUsage() = "Officetel"

}



KS{

     Wall myWall{

          isObjectProperty(Wall.isfireResistantStructure)

     }



     FloorSlab myFloorSlab{

          isObjectProperty(FloorSlab.isFireResistantStructure) = TRUE

     }



     Door myDoor{

          isObjectProperty(Door.isStrictFireproofDoor) = TRUE

     }


Zone myZone{
isObjectProperty(Zone.isHeatingSection) = TRUE
}
     isPartitioned(myZone, myWall) = TRUE

     OR isPartitioned(myZone, myFloorSlab) = TRUE

     OR isPartitioned(myZone, myDoor) = TRUE

}


//건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 7호

Check(RFB_13_1_7){

     KS

}

KS{

     isFireResistantStructure(GasDuct) = TRUE

     isShared(GasDuct) = TRUE

}


//     건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 2항

Check(RFB_13_2){

     IF CS THEN KS

}



CS{

     getBuildingUsage() = "Officetel"

}



KS{

     Wall myWall{

          isObjectProperty(Wall.isfireResistantStructure)

     }



     FloorSlab myFloorSlab{

          isObjectProperty(FloorSlab.isFireResistantStructure) = TRUE

     }



     Door myDoor{

          isObjectProperty(Door.isStrictFireproofDoor) = TRUE

     }


Zone myZone{
isObjectProperty(Zone.isHeatingSection) = TRUE
}
     isPartitioned(myZone, myWall) = TRUE

     OR isPartitioned(myZone, myFloorSlab) = TRUE

     OR isPartitioned(myZone, myDoor) = TRUE

}

//건축물의 설비기준 등에 관한 규칙 14조 (배연설비) 1항 

Check(RFB_14_1){

IF (CS) THEN KS

}



CS {

     isObjectProperty(Floor.isEscape) = FALSE

}



KS {

        isExist(SmokeExhaustionSystem)=TRUE

     getResult(RFB_14_1_1) = TRUE

     AND getResult(RFB_14_1_2) = TRUE

}


//건축물의 설비기준 등에 관한 규칙 14조 (배연설비) 1항 1호

Check(RFB_14_1_1){

     IF (CS) THEN KS1 AND KS2

}



Zone myZone{

          isObjectProperty(Zone.isFirePartition) = TRUE

     }





CS{

     isObjectProperty(Building.isFirePartition) = TRUE

}



KS1{

     

     hasSpace(myZone, SmokeVentilator) = TRUE

     

     getObjectVerticalDistance(SmokeVentilator, Ceiling) < 0.9 m

     OR getObjectVerticalDistance(SmokeVentilator, CeilingCovering) < 0.9 m

}



KS2{     

     IF{

          getSpaceHeight(myZone, b) >= 3 m

     }



     THEN{

          getObjectVerticalDistance(SmokeVentilator, FloorSlab) >= 2.1 m 

     }

}


//건축물의 설비기준 등에 관한 규칙 14조 (배연설비) 1항 2호
Check(RFB_14_1_2){
     IF (CS) THEN (KS1 OR KS2)
}

Zone myZone{
     isObjectProperty(Zone.isFirePartition) = TRUE
}

Space mySpace{
     getSpaceUsage(Space) = "Room"
     getTotalElementArea(Ventilator) >= getFloorArea(Space)*0.05
}

Space mySpace2{
     hasSpace(Space, myZone) = TRUE
     getResult(EDBA_46_1) = TRUE 
     getREsult(EDBA_46_3) = TRUE
}

CS{
     getElementArea(SmokeVentilator) >= 1 m2
     getResult(RFB_*_2) = TRUE
}

KS1{
     getTotalElementArea(Ventilator) >= (getBuildingArea()-getFloorArea(mySpace))*0.01
}

KS2{
     getTotalElementArea(Ventilator) >= (getFloorArea(myZone)-getFloorArea(mySpace))*0.01
}


//건축물의 설비기준 등에 관한 규칙 14조 (배연설비) 2항

Check(RFB_14_2){

IF CS THEN KS

}

CS {     

   

           isObjectProperty(Stair.isSpecialEscape)=TRUE



           OR isObjectProperty(Elevator.isEmergency)=TRUE   

}



KS {

     getResult(RFB_14_2_1) = TRUE

     getResult(RFB_14_2_4) = TRUE

}


//건축물의 설비기준 등에 관한 규칙 14조 (배연설비) 2항1호



Check(RFB_14_2_1){
Duct myDuct{
getObjectProperty(Duct.functionType) = "Exhaust"
}
     isObjectProperty(SmokeExhaustionOpening.Material.nonCombustibility) = TRUE

     isObjectProperty(myDuct.Material.nonCombustibility) = TRUE

     (isConnectedToExternal(SmokeExhaustionOpening) = TRUE

        isConnectedToExternal(myDuct) = TRUE)

     OR( isConnectedTo(SmokeExhaustionOpening,Chimney) = TRUE

            isConnectedTo(myDuct,Chimney) = TRUE)

}


//건축물의 설비기준 등에 관한 규칙 14조 (배연설비) 2항4호

Check(RFB_14_2_4){

     IF    isConnectedToExternal(SmokeExhaustionOpening) = FALSE

           THEN isExist(SmokeExtractor) = TRUE

}

//     건축물의 설비기준 등에 관한 규칙 17조의2 (차수설비) 1항

Check(RFB_17-2_1){

     IF CS THEN KS

}



CS{

     getResult(RFB_17-2_1_1) = TRUE

     OR getResult(RFB_17-2_1_2) = TRUE



     getGrossFloorArea() >= 10000m2

}



KS{

     Floor myFloor{

          getObjectProperty(Floor.number) <0

     }



     hasSpace(myFloor,WaterCutoffSystem) = TRUE

}


//     건축물의 설비기준 등에 관한 규칙 17조의2 (차수설비) 1항 1호
Check(RFB_17-2_1_1){
     KS
}

KS{
     getResult(LPUA_37_1_5) = TRUE
}


//     건축물의 설비기준 등에 관한 규칙 17조의2 (차수설비) 1항 1호

Check(RFB_17-2_1_2){

     KS

}



KS{

     getResult(Unimplemented_CNDA_12_1) = TRUE

}

//건축물의 설비기준 등에 관한 규칙 20 (피뢰설비) 5호

Check(RFB_20_0_5){

   IF(CS1 THEN KS1) OR (CS2 THEN KS2)

}

CS1{

     getBuildingHeight() > 60m

}

KS1{

     BH1 = getBuildingHeight()

     isInstalled(Terminal, Building, a, side) = TRUE

     getObjectVerticalDistance(Ground, Terminal, a) >= BH1 * 4/5

     getObjectVerticalDistance(Ground, Terminal, a) < BH1

}

CS2{

     getBuildingHeight() > 150m

}

KS2{

     BH2 = getBuildingHeight()

     isInstalled(Terminal, Building, a, side) = TRUE

     getObjectVerticalDistance(Ground, Terminal, a) >= 120m

     getObjectVerticalDistance(Ground, Terminal, a) < BH2

}

//건축물의 설비기준 등에 관한 규칙 20조의2 (전기설비 설치공간 기준)

Check(RFB_20-2){
   KS
}



KS{
   getResult(Unimplemented_RFB_*3-3)=True
}

//     건축물의 설비기준 등에 관한 규칙 23조 (건축물의 냉방설비) 3항
Check(RFB_23_3){
     IF CS THEN KS
}

CS{
     getBuildingUsage() = "ResidentialArea"
     OR getBuildingUsage() = "CommercialArea"
}

KS{
     getResult(RFB_23_3_1)
}


//     건축물의 설비기준 등에 관한 규칙 23조 (건축물의 냉방설비) 3항 1호
Check(RFB_23_3_1){
     KS
}

KS{
     getObjectVerticalLocation(AirOutlet, RoadSurface) >= 2m
}

//건축물의 설비기준 등에 관한 규칙 5조 (승용승강기의 설치기준) 

Check(RFB_5){

     IF !(CS) THEN KS1

}

CS{
getObjectProperty(Elevator.usage) = "PassengerElevator"
     isExist(Elevator) = TRUE
}

KS1{
        getResult(RFB_*_1-2) = TRUE
}

//건축물의 설비기준 등에 관한 규칙 6조 (승강기의 구조) 

Check(RFB_6){

     IF CS THEN KS
}
CS{     
     Elevator myElevator{
     isObjectProperty(Elevator.isEmergency) = TRUE
     }

     isInstalled(Elevator) = TRUE
     OR isInstalled(Escalator) = TRUE
     OR isInstalled(myElevator) = TRUE
}

KS{
           getResult(Unimplemented_EFSMA) = TRUE
}

//건축물의 설비기준 등에 관한 규칙 9조 (비상용승강기를 설치하지 아니할 수 있는 건축물)

Check(RFB_9){

   KS
}

KS{
   getResult(RFB_9_0_1)=TRUE
   OR getResult(RFB_9_0_2)=TRUE
   OR getResult(RFB_9_0_3)=TRUE
}


//건축물의 설비기준 등에 관한 규칙 9조 (비상용승강기를 설치하지 아니할 수 있는 건축물) 1호
Check(RFB_9_0_1){
   KS
}

KS{
   Floor myFloor{
     getObjectHeight(Floor)>31 m
    }

   hasObject(myFloor, Room)=FALSE
}


//건축물의 설비기준 등에 관한 규칙 9조 (비상용승강기를 설치하지 아니할 수 있는 건축물) 2호

Check(RFB_9_0_2){

   KS

}



KS{

    getBuildingHeight()>31 m

    getTotalFloorArea()<=500 m2

}


//건축물의 설비기준 등에 관한 규칙 9조 (비상용승강기를 설치하지 아니할 수 있는 건축물) 3호

Check(RFB_9_0_3){

    KS

}



KS{

    getBuildingHeight()>31 m

    getBuildingStoriesCount()<=4

    IF isObjectProperty(Wall.InteriorFinish.Material.nonCombustibility)=TRUE

       isObjectProperty(CeilingCovering.InteriorFinish.Material.nonCombustibility)=TRUE

    THEN isFirePartition(Floor, a,500)=TRUE 

    ELSE THEN isFirePartition(Floor, a,200)=TRUE 

    END IF

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 1항

check(REFB_10_1){

    Space mySpace = getSpace("Auditorium") + getSpace("AssemblyHal"l)



    Door myExit {

        isAccessible(mySpace, Door) = TRUE

        isObjectProperty(Door.isEntrance) = TRUE

    }

getObjectProperty(myExit.panelOperationType) != "OpeningInDoor"


}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항
check(REFB_10_2){
    IF (CS) THEN KS ENDIF
}

CS{
    getBuildingUsage() = "CulturalAndAssemblyFacility.PerformanceHall"

    Space mySpace = getSpace("individualSeats")
    getFloorArea(mySpace) >= 300

KS{
    getResult(REFB_10_2_1) = TRUE
    getResult(REFB_10_2_2) = TRUE
    getResult(REFB_10_2_3) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항 1호

check(REFB_10_2_1){

    Door myExit {

        Door.Space.name = "individualSeats"

        getFloorArea(Door.Space) >= 300

        isObjectProperty(Door.isEntrance) = TRUE

    }



    getObjectCount(myExit) >= 2

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항 2호

check(REFB_10_2_2){

    Door myExit {

        Door.Space.name = "individualSeats"

        getFloorArea(Door.Space) >= 300

        isObjectProperty(Door.isEntrance) = TRUE

    }



    getObjectWidth(myExit) >= 1.5m

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항 3호

check(REFB_10_2_3){

    Door myExit {

        Door.Space.name = "individualSeats"

        getFloorArea(Door.Space) >= 300

        isObjectProperty(Door.isEntrance) = TRUE

    }



    getTotalObjectWidth(myExit) >= getFloorArea(myExit.Space)/100*0.6

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 1항

Check(REFB_11_1){     
IF CS THEN KS1 AND KS2
}

CS {
Door myDoor{
     isObjectProperty(Door.isEntrance)=TRUE
}
isExist(myDoor)
}

KS1 {
Floor myFloor{
     isObjectProperty(Floor.isEscape)=TRUE
}

getObjectDistance(myFloor.Stair, myDoor,a) <= EDBA_34_1.distance

}

KS2 {

getObjectDistance(Room, myDoor) <= (EDBA_34_1.distance)*2

}




//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 2항



Check(REFB_11_2){
     

IF CS1 AND CS2 THEN KS


}





CS1 {

Building myBuilding{

getBuildingUsage() = “CulturalAndAssemblyFacility”

OR getBuildingUsage() = “ReligiousFacility”

OR getBuildingUsage() = “AmusementFacility”

OR getBuildingUsage() = “FuneralParlor”

getBuildingUsage() != “ExhibitionHall”

getBuildingUsage() != “ZoologicalAndBotanicalGarden”

}



Door myDoor{

isObjectProperty(myBuilding.Door.isEntrance)=TRUE

}

isExist(myDoor) = TRUE

}



KS {

getObjectProperty(myDoor.panelOperationType) != “OpeningInDoor”



}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 3항

Check(REFB_11_3){
     

IF CS1 AND CS2 THEN KS


}





CS1 {

Building myBuilding{

getBuildingUsage() = “AssemblyHall”

OR getBuildingUsage() = “PerformanceHall”

}



Space mySpace{

myBuilding.Space.name = “Auditorium”

Space.FloorSlab.area >= 300 m2

}



isExist(mySpace) = TRUE

}



CS2 {

Door myDoor{

isObjectProperty(Door.isEntrance)=TRUE

}

hasObject(myBuilding,myDoor) = TRUE

}



KS {

Door myDoor{

getObjectProperty(Door.functionType) = "Auxiliary"

OR getObjectProperty(Door.functionType) = "Emergency" 

}



getObjectCount(myDoor) >=2

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 4항
Check(REFB_11_4){     
IF CS THEN KS
}

CS {
Floor myFloor{
getObjectUsage(Floor) = “CommercialFacility”
isObjectProperty(Floor.isEscape)=TRUE
}
Door myDoor{
isObjectProperty(Door.isEntrance)=TRUE
}

hasObject(myFloor,myDoor) = TRUE
}

KS{

myFloor.myDoor.effectiveWidth >= 

}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항
Check(REFB_11_5){     
IF CS1 AND CS2 THEN KS
}

CS1 {
getResult(REFB_11_5_1)=TRUE
OR getResult(REFB_11_5_2)=TRUE
OR getResult(REFB_11_5_3)=TRUE
OR getResult(REFB_11_5_4)=TRUE
OR getResult(REFB_11_5_5)=TRUE
OR getResult(REFB_11_5_6)=TRUE
}

CS2{
Floor myFloor{
     isObjectProperty(Floor.isEscape)=TRUE
}

Passage myPassage{
isDirectlyAccessible(myFloor,Passage) = TRUE
OR isDirectlyAccessible(myFloor.Platform,Passage) = TRUE
isConnectedToExternal(Passage) = TRUE
}

isExist(myPassage)=TRUE
}

KS{
hasObject(myPassage,Ramp)=TRUE
getResult(REFB_15_5)=TRUE
}





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항 1호

Check(REFB_11_5_1){
      

KS




}

KS {

Building myBuilding{

getBuildingUsage() = “ClassINeighborhoodLivingFacility.CommunityCenter”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PoliceBox”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PoliceSubstation”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.FireStation”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PostOffice”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.BroadcastingStation”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.HealthCenter”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PublicLibrary”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.RegionalHealthInsuranceAssociation”



}



Space mySpace{

Space.usage=“CommunityCenter”

Space.usage=“PoliceBox”

Space.usage=“PoliceSubstation”

Space.usage=“FireStation”

Space.usage=“PostOffice”

Space.usage=“BroadcastingStation”

Space.usage=“HealthCenter”

Space.usage=“PublicLibrary”

Space.usage=“RegionalHealthInsuranceAssociation”

Space.FloorSlab.area < 1000 m2

}

isExist(myBuilding) = TRUE

isExist(mySpace) = TRUE

}


건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항 2호

Check(REFB_11_5_2){
      

KS


}





KS {

Building myBuilding{

getBuildingUsage() = “ClassINeighborhoodLivingFacility.VillageHall”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.CommunityWorkspace”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.CommunitySalesShop”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.Substation”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PumpingStation”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PurificationPlant”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.Shelter”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PublicLibrary”

OR getBuildingUsage() = “ClassINeighborhoodLivingFacility.PublicToilet”



}



isExist(myBuilding) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항 3호
Check(REFB_11_5_3){젨젨젨
KS
}

KS {
getBuildingUsage() = “CommercialFacility”
OR getBuildingUsage() = “TransportationFacility”
getObjectProperty(Building.grossFloorArea) >= 5000 m2

}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항 4호

Check(REFB_11_5_4){
     

KS


}





KS {

Building myBuilding{

getBuildingUsage() = “EducationAndResearchFacility.School”

}



isExist(myBuliding) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항 5호

Check(REFB_11_5_5){
      

KS


}





KS {

Building myBuilding{

getBuildingUsage() = “BusinessFacility.GovernmentOfficeBuilding”

OR getBuildingUsage() = “BusinessFacility.ForeignOfficialResidence”

getBuildingUsage() != “ClassINeighborhoodLivingFacility”

}



isExist(myBuilding) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 5항 6호

Check(REFB_11_5_6){
KS
}


KS {

hasObject(Building,Elevator)=TRUE

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 6항
Check(REFB_11_6){  
   KS
}

KS{
    Door myDoor{
       isObjectProperty(Door.isEntrance)=TRUE
    }
    IF getObjectMaterial(myDoor)="Glass"
         THEN getObjectType(Glass)="Safety"  

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 12조 (회전문의 설치기준)  
Check(REFB_12){     
IF CS THEN KS
}

CS {
Door myDoor {
isObjectProperty(Door.isEntrance) = TRUE
Door.panelOperationType=“RevolvingDoor”
}
isExist(myDoor) = TRUE
}

KS {
getResult(REFB_12_1)=TRUE
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 12조 (회전문의 설치기준) 1항
Check(REFB_12_1){
KS
}

KS {
getElementDistance(myDoor, Stair, a)>= 2 m
OR getElementDistance(myDoor, Escalator, a)>= 2 m
}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 1항

Check(REFB_13_1){
        KS
}

KS{
   getResult(REFB_13_1_1)=True
   getResult(REFB_13_1_2)=True
   getResult(REFB_13_1_3)=True
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙

Check(REFB){
    IF CS THEN KS1 ELSE KS2
}

CS{
   getObjectLength(Building.RoofTop.FloorSlab)<=22 m
   getObjectWidth(Building.RoofTop.FloorSlab)<=22 m
}

KS1{
   getObjectLength(Heliport)>=15 m
   getObjectWidth(Heliport)>=15 m
}

KS2{
  getObjectLength(Heliport)>=22 m
   getObjectWidth(Heliport)>=22 m
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 1항 2호



Check(REFB_13_1_2){

        KS

}



KS{

    Space mySpace{



    // 헬리포트의 중심으로부터 반경 12미터 이내의 공간        

   }



   isInstalled(Building, mySpace)=False

   isInstalled(Construction, mySpace)=False

   isInstalled(LandscapeFacility, mySpace)=False

   isInstalled(Railing, mySpace)=False

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 2항



Check(REFB_13_2){

    KS

}



KS{  

    Space mySpace{



      getObjectDiameter(Space)>=10 m

    }



   isInstalled(Building, mySpace)=False

   isInstalled(Construction, mySpace)=False

   isInstalled(Railing, mySpace)=False

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항

Check (REFB_13_3){
    KS
}

KS{
    getResult(REFB_13_3_1)=True
    getResult(REFB_13_3_2)=True
    getResult(REFB_13_3_3)=True
    getResult(REFB_13_3_4)=True
    getResult(REFB_13_3_5)=True
    getResult(REFB_13_3_7)=True
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 1호



Check (REFB_13_3_1){

      KS

}



KS{

Space mySpace{
isObjectProperty(Space.isEscape) = TRUE
}
  mySpace.area > Roof.horizontalProjectionArea*0.1

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 2호



Check(REFB_13_3_2){

     KS

}



KS{



   Stair myStair {

    isObjectProperty(Stair.isEscape)=True   

   }



   Stair myStair2 {

    isObjectProperty(Stair.isSpecialEscape)=True   

   }

Space mySpace{
isObjectProperty(Space.isEscape) = TRUE
}

   isConnected(mySpace, myStair )=True 

   OR isConnected(mySpace, myStair2 )=True 

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 3호



Check(REFB_13_3_3){

     KS

}







KS{ 

Space mySpace{
isObjectProperty(Space.isEscape) = TRUE
}

   isFirePartition(mySpace)=True

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 4호



Check(REFB_13_3_4){

  KS

}



KS{

     isObjectProperty(Door.isEntrance)=True

  getObjectProperty( myDoor.effectiveWidth) > 0.9 m

   isObjectProperty(Door.isStrictFireproofDoor)=True


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 5호



Check(REFB_13_3_5){

       KS

}





KS{

Space mySpace{
isObjectProperty(Space.isEscape) = TRUE
}

   isObjectProperty(mySpace.InteriorFinish.Material.nonCombustibility)=True

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 7호

check(REFB_13_3_7){

     KS

}

KS{

     Space mySpace{

     isObjectProperty(Space.isEscape) = TRUE

     }

     hasObject(mySpace, WarningAndCommunicationFacility) = TRUE

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치) 1항


check(REFB_14_1){
KS
}

KS{
     getResult(REFB_14_1_1) = TRUE
     AND getResult(REFB_14_1_2) = TRUE
     AND getResult(REFB_14_1_3) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치) 1항1호



check(REFB_14_1_1){KS

}



KS{

     Floor myFloor{

          Floor.number>=10

     }



     IF (


        isExist(SprinklerSystem)=TRUE 
isObjectProperty(ExtinguishingSystem.isAutomatic) = TRUE


        ) 

     (

        isFirePartition(myFloor, 3000)=TRUE

        OR isFirePartition(myFloor, a, 1000)=TRUE

        )

     

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치) 1항2호

check(REFB_14_1_2){
IF CS THEN KS
}

KS{
  Floor myFloor { 
         Floor.number>=3
         AND Floor.number<0
         }
  isObjectProperty(myFloor.isFirePartition)=TRUE
}



CS{
  Ramp myRamp{
         isGoThrough(getFloor(Floor.number=-1),Ramp,Ground)=TRUE
         }
         isObjectProperty(myRamp.isFirePartition)=FALSE  
}





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의설치) 1항3호





check(REFB_14_1_3){

KS2 AND IF CS THEN KS

}



  

Floor myFloor {

          getFloorNumebr()>= 11

              } 





KS2{

     isFirepartition(myFloor,200)=TRUE 

     OR 

     ((isExist(SprinklerSystem) = TRUE 

      OR isObjectProperty(ExtinguishingSystem.isAutomatic) = TRUE)

      AND isFirepartition(myFloor,600)=TRUE)

}



CS1 {

     isObjectProperty(Space.InteriorFinish.Material.nonCombustibility)=TRUE

}



KS1 {

     isFirepartition(myFloor,500)=TRUE

     OR

      ((isExist(SprinklerSystem) = TRUE 

      OR isObjectProperty(ExtinguishingSystem.isAutomatic) = TRUE)

      AND isFirepartition(myFloor,1500)=TRUE)

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치기준) 3항

Check(REFB_14_3){
     KS
}

 KS{
     getResult(REFB_14_3_1)=True
     getResult(REFB_14_3_2)=True
     getResult(REFB_14_3_3)=True
      getResult(REFB_14_3_4)=True
 }


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치기준) 3항 1호

Check(REFB_14_3_1){
   KS
}

KS{
  Opening myOpening {
       isObjectProperty(Opening.isEscape)=True
  }

  getObjectDiameter(myOpening)>60 cm  
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치기준) 3항 2호

Check(REFB_14_3_2){
       KS
}

KS{
   getObjectVerticalDistance(myOpening, myOpening)> 15 cm  
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조 (방화구획의 설치기준) 3항 4호



Check(REFB_14_3_4){

    KS

}



KS{

   getObjectVerticalDistance(Ladder, Floor.LowerFloor.FloorSlab.Surface, a)<= 50 cm 

}

// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의2 (복합건축물의 피난시설 등)



Check(REFB_14-2){

     IF CS THEN KS

}



CS{


Building myBuilding1{
Building.usage = "MultiUnitHouse" 
   OR Building.usage = "MedicalFacility"

   OR Building.usage =  "ChildrenRelatedFacility"

   OR Building.usage =  "WelfareFacilityForTheAged"
}

 Building myBuilding2{
Building.usage = "AmusementFacility"

   OR Building.usage = "FacilityForStorageAndTreatmentOfDangerousSubstance"

   OR Building.usage = "Factory"

   OR Building.usage = "AutomobileRepairShop"
}

hasObject(Building, myBuilding1) = TRUE
hasObject(Building, myBuilding2) = TRUE


}



KS{

   getResult(REFB_14-2_0_1)=True

   getResult(REFB_14-2_0_2)=True

   getResult(REFB_14-2_0_3)=True

   getResult(REFB_14-2_0_4)=True

   getResult(REFB_14-2_0_5)=True

   

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의2 (복합건축물의 피난시설 등) 1호

Check(REFB_14-2_0_1){
        KS
}

KS{
 Space mySpace{
  Space.usage="MultiUnitHouse"  
  OR Space.usage="MedicalFacility"
  OR Space.usage="ChildrenRelatedFacility"
  OR Space.usage="WelfareFacilityForTheAged"
 }
 
 Space mySpace2{
  Space.usage="AmusementFacility"  
  OR Space.usage="FacilityForStorageAndTreatmentOfDangerousSubstance"
  OR Space.usage="Factory"
  OR Space.usage="AutomobileRepairShop"
 }


getSpaceDiatance(mySpace.Door, mySpace2.Door)>=30 m

}



// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의 2 (복합건축물의 피난시설 등) 2호

Check(REFB_14-2_0_2){
    KS
}

KS{
  Space mySpace{
  Space.usage="MultiUnitHouse"  
  OR Space.usage="MedicalFacility"
  OR Space.usage="ChildrenRelatedFacility"
  OR Space.usage="WelfareFacilityForTheAged"
  }
 
 Space mySpace2{
 Space.usage="AmusementFacility"  
 OR Space.usage="FacilityForStorageAndTreatmentOfDangerousSubstance"
 OR Space.usage="Factory"
 OR Space.usage="AutomobileRepairShop"
 }

 Passage myPassage{
    isAccessible(Passage, mySpace)=True
    OR isAccessible(Passage, mySpace2)=True
 }


 isFirePartition(mySpace)=True
 isFirePartition(mySpace2)=True
 isFirePartition(myPassage)=True
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의2 (복합건축물의 피난시설 등) 3호

Check(REFB_14-2_0_3){
     KS
}

KS{

  Space mySpace{
  Space.usage="MultiUnitHouse"  
  OR Space.usage="MedicalFacility"
  OR Space.usage="ChildrenRelatedFacility"
  OR Space.usage="WelfareFacilityForTheAged"
 }
 
 Space mySpace2{
  Space.usage="AmusementFacility"  
  OR Space.usage="FacilityForStorageAndTreatmentOfDangerousSubstance"
  OR Space.usage="Factory"
  OR Space.usage="AutomobileRepairShop"
 }

 isAdjacent(mySpace, mySpace2)=False

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의2 (복합건축물의 피난시설 등) 4호



Check(REFB_14-2_0_4){

       KS

}



KS{

  isFireResistantStructure(MainStructuralPart)=True

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의2 (복합건축물의 피난시설 등) 5호



Check(REFB_14-2_0_5){

      KS

}



KS{



  Object myObject{

      getObject(Room.wall)

      getObject(Room.CeilingCovering)

  }

   



Corridor myCorridor{

   isGoThrough(Room, Corridor, Ground )=True

}



Stair myStair{

  isGoThrough(Room,Stair, Ground )=True

}



Passage myPassage{

  isGoThrough(Room,Passage, Ground )=True

}



Space mySpace{

   Space.usage==myCorridor.usage

   OR Space.usage==myStair.usage

   OR Space.usage=myPassage.usage



}





Object myObject2{

      getObject(mySpace.wall)

      getObject(mySpace.CeilingCovering)

  }



( isObjectProperty(myObject.InteriorFinish.Material.nonCombustibility)=True

 OR isObjectProperty(myObject.InteriorFinish.Material.quasiNonCombustibility)=True

 OR isObjectProperty(myObject.InteriorFinish.Material.flameResistance)= True
)



isObjectProperty(myObject2.InteriorFinish.Material.nonCombustibility)=True

 OR isObjectProperty(myObject2.InteriorFinish.Material.quasiNonCombustibility)=True





}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 1항

check(REFB_15_1){

     KS

}



KS{

     getResult(REFB_15_1_1)= TRUE

     getResult(REFB_15_1_2)=TRUE

     getResult(REFB_15_1_3)=TRUE

     getResult(REFB_15_1_4)=TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 1항1호
check(REFB_15_1_1){
     IF CS THEN KS
}

CS{
     getObjectHeight(Stair)>3 m
}

KS{
     isExist(StairLanding )= TRUE
     getPaceWidth(StairLanding>=1.2 m
     getObjectCount(StairLanding)>=getObjectCount(getObjectCount(StairLanding))/3
     IF getObjectCount(StairLanding)>1
          THEN   getObjectVerticalDistance(StairLanding ,StairLanding)>3 m   
     END IF 
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 1항2호

check(REFB_15_1_2){

      KS

}



KS{

      

     IF   getObjectHeight(Stair)>1 m 

          OR getObjectHeight(StairLanding)>1 m)

          THEN  isExist(Railing)=TRUE

     END IF

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 1항3호
check(REFB_15_1_3){
     IF !CS THEN KS
}

CS{
      getStairStepHeight()<=15 cm
      getStairStepWidth()>=30 cm
}

KS{
   IF   getObjectWidth(Stair)>=3 m
       
       THEN  hasObject(Stair, Railing) = TRUE
             N=getObjectWidth(Stair)/3
             getObjectCount(Railing)>=N
            IF N>1
                 THEN getObjectDistance(Railing,Railing)<3 m
            END IF
   END IF 
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 1항4호

check(REFB_15_1_4){

     KS

}



KS{

getObjectProperty(Stair.effectiveHeight)>=2.1 m

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 2항
check(REFB_15_2){
     KS
}

KS{
      IF getResult(REFB_15_1)=TRUE

      THEN  getResult(REFB_15_2_1)=TRUE
            getResult(REFB_15_2_2)=TRUE
            getResult(REFB_15_2_3)=TRUE
            getResult(REFB_15_2_4)=TRUE
            getResult(REFB_15_2_5)=TRUE
            getResult(REFB_15_2_6)=TRUE
      END IF 
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 2항1호
check(REFB_15_2_1){
     IF CS THEN KS
}

CS{
      getBuildingUsage()="ElementarySchool"
}

KS{
      getObjectWidth(Stair)>= 150 cm
      getObjectWidth(StairLanding)>150 cm
      getObjectProperty(Stair.riserHeight)>=16 cm
      getObjectProperty(Stair.riserWidth)>=26 cm
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 2항2호
check(REFB_15_2_2){
     IF CS THEN KS
}

CS{
       getBuildingUsage()="MiddleSchool"
       OR getBuildingUsage()="HighSchool"
}

KS{
      getObjectWidth(Stair)>=150 cm
      getObjectWidth(StairLanding)>150 cm
      getObjectProperty(Stair.riserHeight)>=18 cm
      getObjectProperty(Stair.riserWidth)>=26 cm
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 2항3호
check(REFB_15_2_3){
     IF CS THEN KS 
}

CS{
      getBuildingUsage()= "CulturalAndAssemblyFacility.PerformanceHall"
      OR getBuildingUsage()= "CulturalAndAssemblyFacility.AssemblyHall"
      OR getBuildingUsage()= "CulturalAndAssemblyFacility.Auditorium"
      OR getBuildingUsage()= "CommercialFacility "
}

KS{
     getObjectWidth(Stair)>=120 cm
     getObjectWidth(StairLanding)>=120 cm
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 2항4호

check(REFB_15_2_4){

     IF CS THEN KS 

}



CS{  

   Floor myFloor{

   N=getFloorNumber(Stair)

   Floor.number=N+1

   }

   (getTotalFloorArea(myFloor.Room)>=200 m2 

   OR getTotalFloorArea(Room)>=100 m2)

    getFloorNumber(Stair)<0

      

}



KS{

       getObjectWidth(Stair)>=120 cm

      getObjectWidth(StairLanding)>120 cm

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 2항5호
check(REFB_15_2_5){
     KS
}


KS{
      getObjectWidth(Stair)>=120 cm
      getObjectWidth(StairLanding)>120 cm
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙      15조 (계단의 설치기준) 2항 6호



check(REFB_15_2_6){

     IF CS THEN KS

}

CS{

Space mySpace{
getObjectProperty(Space.usage) = "Workplace"
}
     isInstalled(Stair,mySpace) = TRUE

}

KS{

     getResult(ROSHA_26) = TRUE

     getResult(ROSHA_27) = TRUE

     getResult(ROSHA_28) = TRUE

     getResult(ROSHA_29) = TRUE

     getResult(ROSHA_30) = TRUE

}


check(REFB_15_3){

     IF CS THEN KS

}



CS{

       getBuildingUsage()= "ClassINeighborhoodLivingFacility"

OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility"

OR getBuildingUsage() = "CulturalAndAssemblyFacility"

OR getBuildingUsage() = "ReligiousFacility"

OR getBuildingUsage() = "CommercialFacility"

OR getBuildingUsage() = "TransportationFacility"

OR getBuildingUsage() = "MedicalFacility"

OR getBuildingUsage() = "FacilitiesForTheAgedAndChildren"

OR getBuildingUsage() = "BusinessFacility"

OR getBuildingUsage() = "LodgingFacility"

OR getBuildingUsage() = "AmusementFacility"

OR getBuildingUsage() = "FacilityForTourismAndRelaxation"

OR (getBuildingUsage() = "MultiUnitHouse" AND getBuildingUsage() != "Dormitory")

}



KS{

       isExist(Railing)=TRUE 

       OR (isExist(Railing)=FALSE AND isExist(Handle)=TRUE) 

}


check(REFB_15_4){

     KS

}



KS{

       getResult(REFB_15_4_1)=TRUE

       AND getResult(REFB_15_4_2)=TRUE

       AND getResult(REFB_15_4_3)=TRUE

}


check(REFB_15_4_1){

     KS

}

KS{

       getElementWidth(Railing,Handle) >= 3.2CM

       AND getElementWidth(Handle) <= 3.8CM

       getObjectProperty(Handle.sectionShapeType)="Circle" OR "Oval"

}


check(REFB_15_4_2){
     KS
}
KS{
       getObjectDistance(Handle,WallLantern) >= 5CM
       AND getObjectVerticalDistance(Handle,Stair) = 85CM
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙      15조 (계단의 설치기준) 4항 3호

check(REFB_15_4_3){
     KS
}
KS{
    getElementDistance(Handle,Stair.EndPart) <= 30cm
}



건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 5항 
Check(REFB_15_5){     
IF CS THEN KS
}

CS{
isEixst(Ramp)=TRUE 
}
KS {
getResult(REFB_15_5_1)=TRUE
getResult(REFB_15_5_3)=TRUE
}




//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 5항 1호 
Check(REFB_15_5_1){     
KS
}

KS{
getObjectGradient(Ramp) <= 12.5%
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙      15조 (계단의 설치기준) 5항 3호

check(REFB_15_5_3){
     IF CS THEN KS
}
CS{
     isInstalled(Ramp, Building) = TRUE
}
KS{
     getResult(unimplemented_CDAPA) = TRUE
}


//  건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 6항
Check(REFB_15_6){
     IF CS THEN KS
}


Stair myStair{
     getResult(REFB_15_1) = TRUE
}

CS{
     isReplaced(myStair, Ramp) = TRUE
}

KS{
     getResult(REFB_15_5) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 7항
check(REFP_15_7){
     IF CS THEN KS
}

CS{

Floor myFloor{
isObjectProperty(Floor.isEscape)=TRUE
}
      isAccessible(Stair,myFloor) 
      OR isAccessible(Stair,Ground)
}

KS{
      getResult(REFP_15_7_1)
      OR getResult(REFP_15_7_2)
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 7항 1호
check(REFP_15_7_1){
     KS
}

KS{
      getBuildingUsage() = "MultiUnitHouse"
      AND getStairStepWidth >= 1.2M
      AND getPaceWidth >= 1.2M
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 7항 2호
check(REFP_15_7_2){
     KS
}

KS{
      getBuildingUsage() != "MultiUnitHouse"
      AND getStairStepWidth >= 1.5M
      AND getPaceWidth >= 1.5M
}


check(REFP_15_8){

     KS

}



KS{

      getObjectUsage(Stair)= "ElevatorMachineRoom" OR "WatchTower"

      AND getResult(REFP_15_1)=FALSE

      AND getResult(REFP_15_2)=FALSE

      AND getResult(REFP_15_3)=FALSE

      AND getResult(REFP_15_4)=FALSE

      AND getResult(REFP_15_5)=FALSE

      AND getResult(REFP_15_6)=FALSE

      AND getResult(REFP_15_7)=FALSE

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 1항
Check(EDBA_15-2_1){
    IF getBuildingUsage()="Kindergarten"
       OR getBuildingUsage()="ElementarySchool"
       OR getBuildingUsage()="MiddleSchool"
       OR getBuildingUsage()="HightSchool"
       THEN IF isExternal(Corridor)=FALSE
             THEN getObjectProperty(Corridor.effectiveWidth)>2.4 m   
     ELSE THEN  getObjectProperty(Corridor.effectiveWidth)>1.8 m
            END IF
     END IF  


     IF getBuildingUsage()="MultiUnitHouse"
       OR getBuildingUsage()="Officetel"
       THEN IF isExternal(Corridor)=FALSE
             THEN getObjectProperty(Corridor.effectiveWidth)>1.8 m
            ELSE THEN  getObjectProperty(Corridor.effectiveWidth)>1.2 m
            END IF
     END IF  


     IF getTotalFloorArea(Corridor.Floor.Room)>200 m2 
     THEN IF isExternal(Corridor)=FALSE
             THEN IF getBuildingUsage()="MedicalFacilities"
                       THEN getObjectProperty(Corridor.effectiveWidth)>1.8 m
                  ELSE THEN getObjectProperty(Corridor.effectiveWidth)>1.5 m
                  END IF
          ELSE THEN  getObjectProperty(Corridor.effectiveWidth)>1.2 m
          END IF
     END IF  
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 1항

Check(REFB_15-2_1){
            KS
}

KS{

  IF (Building.usage="Kindergarten"
      OR Building.usage="ElementarySchool"
      OR Building.usage="MiddleAndHighSchool" )
      IF(isAdjacent(Corridor, Room)=True)
         THEN   Corridor.width>=2.4 m
            ELSE THEN  Corridor.width>=1.8 m                 
      END IF 

  ELSE IF( Building.usage="MultiUnitHouse"
           OR Building.usage="Officetels" )
         IF( isAdjacent(Corridor, Room)=True)
            TEHN  Corridor.width>=1.8 m
         ELSE THEN Corridor.width>=1.2 m
         END IF
  ELSE IF( Floor.One.Room.area > 200 m2) 
          IF(isAdjacent(Corridor, Room)=True)
             TEHN IF (Building.usage="MedicalFacility")
                   THEN Corridor.width>=1.8 m
             ELSE THEN  Corridor.width>=1.5 m
             
          ELSE THEN Corridor.width>=1.2 m
          END IF
  END IF

}

















//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 2항

check(REFB_15-2_2){

     IF CS THEN KS 

}



CS{

Space  mySpace{

getSpaceUsage(Space) = “AssemblyHall”

OR getSpaceUsage(Space) = “PerformanceHall”

}

    Corridor myCorridor{

       isAdjacent(mySpace,Corridor) = TRUE

    }



    (getBuildingUsage()="CulturalAndAssemblyFacility.PerformanceHall"

    OR getBuildingUsage()="CulturalAndAssemblyFacility.AssemblyHall"

    OR getBuildingUsage()="CulturalAndAssemblyFacility.Auditorium"

    OR getBuildingUsage()="CulturalAndAssemblyFacility.ExhibitionHall"

    OR getBuildingUsage()="ReligiousFacility.ReligiousAssemblyFacility"

    OR getBuildingUsage()="FacilitiesForTheAgedAndChildren.ChildrenRelatedFacility"

    OR getBuildingUsage()="FacilitiesForTheAgedAndChildren.WelfareFacilityForTheAged"

    OR getBuildingUsage()="Trainingfacility.TrainingFacilitiesInLiving "

    OR getBuildingUsage()="AmusementFacility.tavern"

    OR getBuildingUsage()="AmusementFacility.FuneralParlors" )

     

    isExist(myCorridor)=TRUE   

}



KS{



 

   getResult(REFB_15-2_2_1)=TRUE

   getResult(REFB_15-2_2_2)=TRUE

   getResult(REFB_15-2_2_3)=TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 2항1호
check(REFB_15-2_2_1){
     KS
}
KS{ 
     IF getTotalFloorArea(Corridor.Floor.Space)<500 m2
       THEN getObjectProperty(Corridor.effectiveWidth)>=1.5 m
     END IF 
     
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 2항2호
check(REFB_15-2_2_2){
     KS
}
KS{ 
    IF getTotalFloorArea(Corridor.Floor.Space)>=500 m2
       getTotalFloorArea(Corridor.Floor.Space)<1000 m2
         THEN getObjectProperty(Corridor.effectiveWidth)>=1.8 m
     END IF 
}





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 2항3호
Check(REFB_15-2_2_3){
     KS
}
KS{ 
     IF getTotalFloorArea(Corridor.Floor.Space)>=1000 m2
        THEN getObjectProperty(Corridor.effectiveWidth)>=2.4 m
     END IF
}





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 3항
Check(REFB_15-2_3){
   IF CS THEN KS
}

CS{
   getSpaceUsage(Space)="CulturalAndAssemblyFacility.PerformanceHall"
   isExist(Corridor)=TRUE
}
KS{
    
     getResult(REFB_15-2_3_1) = TRUE
     getResult(REFB_15-2_3_2) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 3항1호
Check(REFB_15-2_3_1){
  IF CS THEN KS
}

CS{
    Space mySpace{
       getSpaceUsage(Space)="IndividualAuditorium"
    }

    getFloorArea(mySpace)>300 m2
}

KS{

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 3항2호



Check(REFB_15-2_3_2){

  IF CS THEN KS

}







CS{

    Space mySpace{

       getSpaceUsage(Space)="IndividualAuditorium"

    }



    getFloorArea(mySpace)>300 m2

    getObjectCount(Floor.One.mySpace)>=2 



}



KS{



}

// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 16조 (거실의 반자높이) 1항

check(REFB_16_1){

     IF (CS) THEN KS

}



CS{

     getResult(REFB_16_2) = FALSE

}



KS{

     getSpaceHeight(Room, b) >= 2.1m

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 16조 (거실의 반자높이) 2항

check(REFB_16_2){

IF (CS1 AND CS2) THEN KS

}



CS1{



VentilatorEquipment myVentilatorEquipemnt{

isObjectProperty(VentilatorEquipment.isMechanical)=TRUE

}

     isExist(myVentilatorEquipemn) = FALSE 

}



CS2{

     Space mySpace{

          getSpaceUsage(Space) = “Auditorium”

          OR getSpaceUsage(Space) = “AssemblyHall”

     }



     ((getBuildingUsage() = “CulturalAndAssemblyFacilities.Tavern”

     getBuildingUsage() != “ExhibitionHalls.Tavern”

     getBuildingUsage() != “ZoologicalAndBotanicalGardens.Tavern”)

     OR getBuildingUsage() = "ReligiousFacilities.Tavern”

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 17조 (채광 및 환기를 위한 창문등) 1항

check(REFB_17_1){

     IF (getResult(REFB_*_1-3) = FALSE) THEN KS

}



KS{ 

     Window myWindow{

          hasElement(Room, myWindow) = TRUE

     }

     

     getElementArea(myWindow) >= getFloorArea(Room)*0.1

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 17조 (채광 및 환기를 위한 창문등) 2항

check(REFB_17_2){

     IF !CS THEN KS

}



CS{

     AirConditioningSystem myAirConditioningSystem{

          isObjectProperty(AirConditioningSystem.isCentralControl)

     }



VentilatorEquipment myVentilatorEquipemnt{

isObjectProperty(VentilatorEquipment.isMechanical)=TRUE

}



     hasElement(Room, myVentilatorEquipemnt)= TRUE 

     OR hasElement(Room, myAirConditioningSystem) = TRUE

}



KS{

     Window myWindow{

          hasElement(Room, Window) = TRUE

     }

          getElementArea(myWindow) >= getFloorArea(Room)*0.05

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 17조 (채광 및 환기를 위한 창문등) 3항

check(REFB_17_3){

     IF CS THEN KS

}



CS{

Door myDoor{
getObjectProperty(Door.panelOperationType) = "SlidingDoor"
}

     Room myRoom{

          isPartitioned(Room, myDoor, Room) = TRUE

     }

}



KS{

     myRoom = Room

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 17조 (채광 및 환기를 위한 창문등) 4항

check(REFB_17_4){

     getObjectHeight(Railing) >= 1.2 m

     OR getObjectHeight(FallPreventionSafetyFacility) >= 1.2 m

     

}

// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 18조 (거실등의 방습) 1항





Check(REFB_18_1){

IF !CS THEN KS}







KS{

 getObjectHeight(getFloor(BottomFloor))>=45CM

}





CS {

 isObjectProperty(Ground.Surface.isDampProof)=TRUE 

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 18조 (거실등의 방습) 2항





Check(REFB_18_2){

  IF CS THEN KS

}



CS{

 getResult(REFB_18_2_1)=TRUE

 OR getResult(REFB_18_2_2)=TRUE

}



KS{

  Finish myFinish{

    getObjectDistance(Finish,floor)<=1



  isObjectPropert(InteriorFinish.Material.waterResistance)=TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 18조 (거실등의방습) 2항1호





Check(REFB_18_2_1){

KS

}







KS{

Space mySpace1{
getSpaceUsage() = "Bathroom"
}
Space mySpace2{
getSpaceUsage() = "Kitchen"
}

getBuildingUsage(mySpace1.Building) = "ClassINeighborhoodLivingFacility.BathHouse"
OR 
 getBuildingUsage(mySpace2.Building) = "ClassINeighborhoodLivingFacility.RestingRestaurant"


}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 18조 (거실등의 방습) 2항 2호



Check(REFB_18_2_2){

KS

}



KS{

Space mySpace1{
getSpaceUsage() = "Kitchen"
}
Space mySpace2{
getSpaceUsage() = "Bathroom"
}

getBuildingUsage(mySpace1.Building) = "ClassINeighborhoodLivingFacility.Restarant"
OR 
 getBuildingUsage(mySpace2.Building) = "ClassINeighborhoodLivingFacility.LodgingFacilities"

}

check(REFB_19_1){

     KS

}



KS{

Wall myWall{
   isObjectProperty(Wall.isPartitionWall) = TRUE
}
Floor myFloor{
hasObject(Floor, myWall)
}
   isFireResistantStructure(myWall)=TRUE
(isConnectedTo(myWall, Roof.BottomSurface) = TRUE
 OR isCOnnectedTo(myWall, myFloor.UpperFloor.FloorSlab) = TRUE)

}


check(REFB_19_2){
     KS
}

KS{
   getResult(REFB_19_2_1)= TRUE
   OR getResult(REFB_19_2_2)= TRUE
   OR getResult(REFB_19_2_3)= TRUE
   OR getResult(REFB_19_2_4)= TRUE
   OR getResult(REFB_19_2_5)= TRUE
}


check(REFB_19_2_1){

     KS

}



KS{
Wall myWall{
   isObjectProperty(Wall.isPartitionWall) = TRUE
}
   getObjectProperty(myWall.Structure.materialType) = "ReinforcedConcrete" OR "SteelFramedReinforcedConcrete" 

   AND getObjectThickness(myWall) >= 10CM

}


check(REFB_19_2_2){

     KS

}



KS{
Wall myWall{
   isObjectProperty(Wall.isPartitionWall) = TRUE
}

   getObjectProperty(myWall.Structure.materialType) = "PlainConcrete" OR "Stone" 
 getObjectThickness(myWall) >= 10CM

}


check(REFB_19_2_3){

     KS

}



KS{
Wall myWall{
   isObjectProperty(Wall.isPartitionWall) = TRUE
}

   getObjectProperty(myWall.Structure.materialType) = "ConcreteBlock" OR "Brick" 
 getObjectThickness(myWall) >= 19CM

}

check(REFB_20){

     KS

}



KS{

     isExist(Chimney)=TRUE

     AND (getResult(REFB_20_0_1)=TRUE

       

          AND getResult(REFB_20_0_3)=TRUE

          AND getResult(REFB_20_0_4)=TRUE)

}


check(REFB_20_0_1){
     KS
}

KS{
     getObjectDistance(Chimney, Ground)
     -getObjectDistance(Roof, Ground)>= 1M
} 



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 20조 (건축물에 설치하는 굴뚝) 3호
Check(REFB_20_0_3){
     IF CS THEN KS
}

CS{
     getObjectMaterial(Chimney.Material.nonCombustibility) = TRUE
}

KS{
     Chimney myChimney{
          getObjectMaterial(Chimney.Material.nonCombustibility) = TRUE
     }

     isObjectProperty(A.Finish.Material.nonCombustibility) = TRUE
     getObjectProperty(A.Finish.Material.nonCombustibility) != 
     isObjectProperty(B.Finish.Material.nonCombustibility) = TRUE
     getFloorNumber(myChimney) = LF
     getObjectMaterial(myChimney) != "Metal"
}


check(REFB_20_0_4){

IF !CS THEN KS

}



CS{

     (isObjectProperty(Chimney.Material.nonCombustibility)= TRUE

     AND !(getObjectProperty(Chimney.Material)="Metal"))

     And getElementWidth(NoncombustibleMaterials)>=10

}



KS{

       getObjectDistance(Chimney, combustibleMaterials)>= 15CM

       AND getObjectProperty(Chimney.Material)="Metal")) 

}

check(REFB_20-2){

     getResult(REFB_*_2) = True

     getObjectProperty(MainStructuralPart.Material.nonCombustibility)= TRUE

     getBuildingStoriesCount()<2;

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 21조 (방화벽의 구조) 1항

Check(REFB_21_1){
     KS 
}

KS{
   getResult(REFB_21_1_1)=True
   getResult(REFB_21_1_2)=True
   getResult(REFB_21_1_3)=True
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 21조 (방화벽의 구조) 1항 1호

Check(REFB_21_1_1){
     KS
}

KS{
   Wall myWall{
       isObjectProperty(Wall.isFireProofWall)=True
   }
   
   isObjectProperty(myWall.isfireResistantStructure)=True
}




//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 21조 (방화벽의 구조) 1항 2호

Check(REFB_21_1_2){
     KS
}

KS{
   Object myObject{
      //방화벽의 양쪽 끝과 윗쪽 끝
   }  

   Wall myWall{
      isObjectProperty(Wall.isExternal)=True
   }

    getObjectDistance(myObject, myWall)>=0.5 m
    getObjectDistance(myObject, Roof)>=0.5 m
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 21조 (방화벽의 구조) 1항 3호

Check(REFB_21_1_3){
      KS
}

KS{
     Door myDoor{
      isObjectProperty(Door.isEntrance)=True
      isInstalled(Door, myWall)=True
    }

    getObjectWidth(myDoor)<=2.5 m
    getObjectHeight(myDoor)<=2.5 m
    isObjectProperty(myDoor.isStrictFireproofDoor)=True
  
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 21조 (방화벽의 구조) 2항
Check(REFB_21_2){
     KS
}

KS{
     getResult(REFB_14_1) = TRUE
     getResult(REFB_14_2) = TRUE
}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 23조 (방화지구안의 지붕ㆍ방화문 및 외벽등) 1항

Check(REFB_23_1){

     IF CS THEN KS

}



CS{


     Building myBuilding{
getObjectProperty(Building.SpecialPurposeDistrict.type) = "FirePreventionDistrict"
     }



     Roof myRoof{

          hasObject(myBuilding, Roof) = TRUE

     }



     isObjectProperty(myRoof.isFireResistantStructure) != TRUE

}



KS{

     isObjectProperty(myRoof.Material.nonCombustibility) = TRUE

}

check(REFB_24_1){

      KS}



KS{

    (check(EDBA_61_1_1)=TRUE

    OR check(EDBA_61_1_2)=TRUE

    OR check(EDBA_61_1_3)=TRUE

    OR check(EDBA_61_1_4)=TRUE)

    OR check(EDBA_61_1_5)=TRUE)

    OR check(EDBA_61_1_6)=TRUE)

    OR check(EDBA_61_1_7)=TRUE)

    AND (getObjectProperty(Room.Wall.Material.noncombustible)= TRUE

    AND (getObjectProperty(CeilingCornice | WindowSill.Material.noncombustible)= TRUE

    OR !(getObjectProperty(CeilingCornice | WindowSill.Material.noncombustiblel)= TRUE)

    AND (isGoThrough(Room, Corridor | Stair | Passage,Ground)= TRUE

    AND (isFireResistant(getWall(Corridor))=TRUE

    AND isFireResistant(getWall(Stair))=TRUE

    AND isFireResistant(getWall(Passage))=TRUE

    AND isFireResistant(getObject(CeilingCovering))=TRUE)

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조 (건축물의 마감재료) 2항



check(REFB_24_2){

     IF CS THEN KS

}





CS{

    getResult(REFB_24_2_1)=TRUE

    OR getResult(REFB_24_2_2)=TRUE

}



KS{

  (isObjectProperty(CeilingCovering.InteriorFinish.Material.nonCombustibility)=TRUE

OR isObjectProperty(CeilingCovering.InteriorFinish.Material.quasiNonCombustibility)=TRUE )


(isObjectProperty(Room.Wall.InteriorFinish.Material.nonCombustibility)=TRUE

 OR isObjectProperty(Room.Wall.InteriorFinish.Material.quasiNonCombustibility)=TRUE

)

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조 (건축물의 마감재료) 2항1호
check(REFB_24_2_1){
       KS
}

KS{

  Building myBuilding{
     getResult(EDBA_61_1_1)=TRUE
      OR getResult(EDBA_61_1_2)=TRUE
      OR getResult(EDBA_61_1_3)=TRUE
      OR getResult(EDBA_61_1_4)=TRUE
      OR getResult(EDBA_61_1_5)=TRUE
      OR getResult(EDBA_61_1_6)=TRUE
      OR getResult(EDBA_61_1_7)=TRUE
  }
     
  Room myRoom{
      getSpace(myBuilding.Room)
  }
    getFloorNumber(myRoom)<0 

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조 (건축물의 마감재료) 2항2호
check(REFB_24_2_2){
       KS
}

KS{
     Building myBuilding{
       getResult(EDBA_61_1_1)=TRUE
    }
      
    str= myBuilding.usage

    getSpaceUsage(Room)=str
}




check(REFB_24_3){
      KS
}

KS{
     
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조 (건축물의 마감재료) 4항


Check(REFB_24_4){
IF CS THEN KS
}

Building myBuilding{
getResult(EDBA_61_1_2)=TRUE
}

CS{
isExist(myBuilding)=TRUE
}

KS{
isObjectProperty(myBuilding.Material.isEmittingPollutant)=FALSE
}

// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 1항

check(REFB_24-2_1){

      KS

}

KS{

     getResult(REFB_*_3) = TRUE

     (getBuildingUsage() != "Dormitory"

     OR getBuildingUsage() != "Cafeteria"

     OR getSpaceUsage() != "Dormitory"

     OR getSpaceUsage() != "Cafeteria")

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 2항
check(REFB_24-2_2){
      KS
}
KS{
     Door myDoor{
     isObjectProperty(Door.isEntrance) = TRUE
     }
     getObjectDistance(Building.IndoorElement, Door) <= 30
     isObjectProperty(Door.effectiveWidth) >= 1.5m
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 3항

Check(REFB_24-2_3){
    KS
}

KS{
    getResult(REFB_24-2_3_2)=True
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2
Check(REFB_24-2_3_2){
   KS
}

KS{
   getResult(REFB_24-2_3_2_가)= True
   OR getResult(REFB_24-2_3_2_나)= True
   OR getResult(REFB_24-2_3_2_다)= True
}


//  건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 3항 2호 가목

Check(REFB_24-2_3_2_1){

     KS

}



KS{

     getObjectMaterial(Heartwood) = "FiringPolystyreneInsulation"

}


//  건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 3항 2호 나목

Check(REFB_24-2_3_2_2){

     KS

}



KS{

     getObjectMaterial(Heartwood) = "ChangePolyurethanFormInsulation"

}


//  건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 3항 2호 다목
Check(REFB_24-2_3_2_3){
     IF CS THEN KS
}

CS{
     getResult(REFB_24-2_3_2_1) = FALSE
     getResult(REFB_24-2_3_2_2) = FALSE
}

KS{
     getObjectProperty(Heartwood.Material.flameResistance) = TRUE
     OR getObjectProperty(Heartwood.Material.nonCombustibility) = TRUE
     OR getObjectProperty(Heartwood.Material.quasiNonCombustibility) = TRUE
}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항
check(REFB_25_1){
KS
}


KS{
     getResult(REFB_25_1_1) = TRUE
     AND getResult(REFB_25_1_1-2) = TRUE
     AND getResult(REFB_25_1_2) = TRUE
     AND getResult(REFB_25_1_3) = TRUE
     AND getResult(REFB_25_1_4) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 1호

check(REFB_25_1_1){

     IF !(CS) THEN KS

}



KS{

     Floor myFloor1{

          hasSpace(Floor,Room) = TRUE

          getTotalArea(Room) >= 50 m2

     }



     Floor myFloor2{

          isObjectProperty(Floor.isEscape) = TRUE

     }



     Door myDoor{

          isObjectProperty(Door.functionType) = "Emergency"

          (isDirectlyAccessible(Door, myFloor2) = TRUE

          OR isDirectlyAccessible(Door, Ground) = TRUE)

     }

     

     hasSpace(myFloor1, myDoor)

     OR (hasSpace(myFloor1, VentilatorPipe) = TRUE

     (isDirectlyAccessible(VentilatorPipe, myFloor2) = TRUE

     OR isDirectlyAccessible(VentilatorPipe, Ground) = TRUE))

}



CS{

     Floor myFloor1{

          hasSpace(Floor,Room) = TRUE

          getTotalArea(Room) >= 50 m2

     }



     Stair myStair{

          isObjectProperty(Stair.isDirect) = TRUE

          hasSpace(myFloor1, Stair) = TRUE

     }



     getObjectCount(myStair) >= 2

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 1의2호
check(REFB_25_1_1-2){
     IF CS THEN KS
}

CS{
     (getBuildingUsage() = "ClassIINeighborhoodLivingFacility.PerformanceHall"
     OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.Pubs"
     OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.BilliardRoom"
     OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.Karaoke"
     OR getBuildingUsage() = "CulturalAndAssemblyFacility.WeddingHall"
     OR getBuildingUsage() = "CulturalAndAssemblyFacility.PerformanceHall"
     OR getBuildingUsage() = "TrainingFacility.TrainingFacilityInLivingZone"
     OR getBuildingUsage() = "TrainingFacility.??LivingZone"
     OR getBuildingUsage() = "LodgingFacility.Inn"
     OR getBuildingUsage() = "AmusementFacility.Pubs"
     OR getBuildingUsage() = "AmusementFacility.Tavern"
     OR getResult(ERSASP_2) = TRUE)

     getTotalFloorArea(Room) >= 50 m2
}

KS{
     Stair myStair{
          isObjectProperty(Stair.isDirect) = TRUE
     }

     getObjectCount(myStair) >= 2
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 2호

check(REFB_25_1_2){

     IF CS THEN KS

}



CS{

     getTotalFloorArea(Floor) >= 1000 m2

}



KS{

     Floor myFloor{

          isObjectProperty(Floor.isEscape) = TRUE

     }



     Stair myStair{

          isObjectProperty(Stair.isDirect) = TRUE



          (isDirectlyAccessible(Stair, Ground) = TRUE

          OR isDirectlyAccessible(Stair, myFloor) = TRUE)



          (isObjectProperty(Stair.isEscape) = TRUE

          OR isObjectProperty(Stair.isSpecialEscape) = TRUE)

     }



     Zone myZone{

          isObjectProperty(Zone.isFirePartition) = TRUE

     }



     hasSpace(myZone, myStair) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 3호
check(REFB_25_1_3){
     getTotalFloorArea(Room) >= 1000 m2
     isExist(VentilationSystem) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 4호

check(REFB_25_1_4){

Floor myFloor{
Floor.number < 0
}
     getTotalFloorArea(myFloor) >= 300 m2

     getObjectCount(Hydrant) >= 1

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항
check(REFB_25_2){
     IF !(CS) THEN KS
}

CS{
     getBuildingUsage() = "House"
}

KS{
     getResult(REFB_25_2_1) = TRUE
     getResult(REFB_25_2_2) = TRUE
     getResult(REFB_25_2_3) = TRUE
     getResult(REFB_25_2_4) = TRUE
     getResult(REFB_25_2_5) = TRUE
     getResult(REFB_25_2_7) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 1호

check(REFB_25_2_1){

Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}
     getObjectWidth(myDoor, a) >= 0.75 m 

     getObjectHeight(myDoor) >= 1.5 m

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 2호

Check(REFB_25_2_2){

Door myDoor{
Door.functionType = "Emergency"
 < 0
}
     isEgressDirection(myDoor) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 3호

check(REFB_25_2_3){

Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}
     getSpaceDistance(myDoor, Door) >= 3 m 

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 4호

check(REFB_25_2_4){

     IF CS THEN KS

}



CS{
Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}
Floor myFloor{
Floor.number < 0 
}
     getObjectVerticalDistance(myFloor, myDoor) >= 1.2 m

}



KS{

     isConnectedTo(Wall, Ladder) = TRUE

     getObjectProperty(Ladder.footholdWidth) >= 20 cm

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 5호

check(REFB_25_2_5){

     

     Floor myFloor(

          isObjectProperty(Floor.isEscape) = TRUE

     )



     Stair myStair{

          isObjectProperty(Stair.isDirect) = TRUE

          (isDirectlyAccessible(Stair, Ground) = TRUE

          OR isDirectlyAccessible(Stair, myFloor) = TRUE)

     }



     Corridor myCorridor{

          isDirectlyAccessible(Corridor, myFloor) = TRUE

          OR isDirectlyAccessible(Corridor, Ground) = TRUE

     }

Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}

     (isDirectlyAccessible(myDoor, myStair) = TRUE

     OR isDirectlyAccessible(myDoor, myCorridor) = TRUE

     OR isGoThrough(myDoor, Corridor, myStair) = TRUE

     OR isGoThrough(myDoor, Corridor, myCorridor) = TRUE)

Passage myPassage{
isObjectProperty(Passage.isEscape) = TRUE
}

     getSpaceWidth(myPassage) >= 0.75 m



     isObjectProperty(myPassage.InteriorFinish.Material.nonCombustibility) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 7호

check(REFB_25_2_7){     
Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}

Light myLight{
isObjectProperty(Light.isEmergency) = TRUE
}

Passage myPassage{
isObjectProperty(Passage.isEscape) = TRUE
}

     hasElement(myDoor, LeadingLight) = TRUE

     hasElement(myPassage, myLight) = TRUE

}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 29조 (피난용승강기의 설치 및 구조) 1항 



Check(REFB_29_1){

   IF (!CS1 AND CS2)THEN KS 

}



CS1{



   Building myBuilding{

         isObjectProperty(Building.isQuasiHighriseBuilding )=True

   }



    getBuildingUsage()="myBuilding.MultiUnitHouse"

}

CS2{

    isObjectProperty(Building.isHighBuilding) = TRUE

}

KS{

   getResult(REFB_30)=True

   getResult(REFB_29_2)=True

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 29조 (피난용승강기의 설치 및 구조) 2항 

Check(REFB_29_2){
       KS
}

KS{
   getResult(Unimplemented_EFSMA)
    
}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조)

Check (REFB_3){
    getResult(REFB_3_1)=TRUE
    getResult(REFB_3_4)=TRUE
    getResult(REFB_3_6)=TRUE
    getResult(REFB_3_7)=TRUE
    getResult(REFB_3_8)=TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호

Check (REFB_3_0_1){
     IF CS THEN KS
}
CS{
     isInstalled(Wall) = TRUE
}
KS{
     getResult(REFB_3_0_1_가)=TRUE
    getResult(REFB_3_0_1_나)=TRUE
    getResult(REFB_3_0_1_다)=TRUE
    getResult(REFB_3_0_1_라)=TRUE
    getResult(REFB_3_0_1_마)=TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호 가목

Check (REFB_3_0_1_가){
     KS
}
KS{
     getObjectProperty(Wall.Structure.materialType) = "ReinforcedConcrete" OR "SteelFramedReinforcedConcrete"
     getWallThickness(Wall) >= 10cm
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호 나목

Check (REFB_3_0_1_나){
     KS
}
KS{
     getObjectProperty(Wall.Structure.materialType) = "SteelFrame"  
     (isInstalled(WireMeshMortar, Wall.DoubleSide) = TRUE
     getObjectWidth(WireMeshMortar) >= 4cm)
     (isInstalled(ConcreteBlock, Wall.DoubleSide) = TRUE 
     OR (getObjectWidth(ConcreteBlock) >= 5cm )
     (isInstalled(Brick, Wall.DoubleSide) = TRUE
     OR getObjectWidth(Brick) >= 5cm )
     (isInstalled(Stone, Wall.DoubleSide) = TRUE
     OR getObjectWidth(Stone) >= 5cm)
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호 다목

Check (REFB_3_0_1_다){
     IF CS THEN KS
}
CS{
getObjectProperty(Wall.Structure.materialType) = "ConcreteBlock" OR "Brick" OR "Stone"
isObjectProperty(Structure.isReinforcedSteelStructure) = TRUE
}
KS{
getObjectThickness(Wall.Structure) >= 5cm
}     



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호 라목

Check (REFB_3_0_1_라){
     KS
}

KS{
     getObjectProperty(Wall.Structure.materialType) = "Brick"
     getObjectThickness(Wall.Structure) >= 19cm
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호 마목

Check (REFB_3_0_1_마){
     KS
}
KS{
     getObjectProperty(Wall.Structure.materialType) = "AeratedConcretePanel" OR "AeratedConcreteBlock"
     getObjectThickness(Wall.Structure) >= 10cm
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 4호

Check (REFB_3_0_4){
     IF CS THEN KS
}
CS{
     isInstalled(FloorSlab) = TRUE
}
KS{
     getResult(REFB_3_0_4_가)=TRUE
    getResult(REFB_3_0_4_나)=TRUE
    getResult(REFB_3_0_4_다)=TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 4호 가목

Check (REFB_3_0_4_가){
     KS
}
KS{
     getObjectProperty(Wall.Structure.materialType) = "ReinforcedConcrete" OR "SteelFramedReinforcedConcrete"
     getObjectThickness(FloorSlab.Structure) >= 10cm
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 1호 다목

Check (REFB_3_0_4_나){
     IF CS THEN KS
}
CS{
getObjectProperty(FloorSlab.Structure.materialType) = "ConcreteBlock" OR "Brick" OR "Stone"
isObjectProperty(Structure.isReinforcedSteelStructure) = TRUE
}
KS{
getObjectThickness(FloorSlab.Structure) >= 5cm
}     



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 4호 다목

Check (REFB_3_0_4_다){
     KS
}
KS{
     (isInstalled(WireMeshMortar, Steel.DoubleSide) = TRUE
     getObjectWidth(WireMeshMortar) >= 5cm)
     OR (isInstalled(ConcreteBlock, Wall.DoubleSide) = TRUE 
     getObjectWidth(ConcreteBlock) >= 5cm)
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 6호

Check (REFB_3_0_6){
     IF CS THEN KS
}
CS{
     isInstalled(Roof) = TRUE
}
KS{
     getResult(REFB_3_0_6_가)=TRUE
    getResult(REFB_3_0_6_나)=TRUE
    getResult(REFB_3_0_6_다)=TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 6호 가목

Check (REFB_3_0_6_가){
     KS
}
KS{
     getObjectProperty(Roof.Structure.materialType) = "ReinforcedConcrete" OR "SteelFramedReinforcedConcrete"
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 6호 나목

Check (REFB_3_0_6_나){
     IF CS THEN KS
}
CS{
getObjectProperty(Roof.Structure.materialType) = "ConcreteBlock" OR "Brick" OR "Stone"
isObjectProperty(Structure.isReinforcedSteelStructure) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 6호 다목

Check (REFB_3_0_6_다){
     IF CS THEN KS
}
CS{
getObjectProperty(Roof.Structure.materialType) = "GlassBlock" OR "WiredSheetGlass"
isObjectProperty(Structure.isReinforcedSteelStructure) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 7호

Check (REFB_3_0_7){
     IF CS THEN KS
}
CS{
     isInstalled(Stair) = TRUE
}
KS{
     getResult(REFB_3_0_7_가)=TRUE
    getResult(REFB_3_0_7_나)=TRUE
    getResult(REFB_3_0_7_다)=TRUE
    getResult(REFB_3_0_7_라)=TRUE
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 7호 가목

Check (REFB_3_0_7_가){
     KS
}
KS{
     getObjectProperty(Stair.Structure.materialType) = "ReinforcedConcrete" OR "SteelFramedReinforcedConcrete"
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 7호 나목

Check (REFB_3_0_7_나){
     KS
}
KS{
     getObjectProperty(Stair.Structure.materialType) = "PlainConcrete" OR "ConcreteBlock" OR "Brick" OR "Stone"
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 7호 다목

Check (REFB_3_0_7_다){
     IF CS THEN KS
}
CS{
getObjectProperty(Stair.Structure.materialType) = "ConcreteBlock" OR "Brick" OR "Stone"
isObjectProperty(Structure.isReinforcedSteelStructure) = TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 7호 라목

Check (REFB_3_0_7_라){
     KS
}
KS{
getObjectProperty(Stair.Structure.materialType) = "SteelFrame"
}

// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준)
check(REFB_30){
      IF CS THEN KS
}
CS{
     getResult(REFB_29_1) = TRUE
}
KS{
     getResult(REFB_30_0_1) = TRUE
     getResult(REFB_30_0_2) = TRUE
     getResult(REFB_30_0_3) = TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호
check(REFB_30_0_1){
       KS
}
KS{
     getResult(REFB_30_0_1_가) = TRUE
     getResult(REFB_30_0_1_나) = TRUE
     getResult(REFB_30_0_1_다) = TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호 가목

check(REFB_30_0_1_가){

      KS

}

KS{

     FloorSlab myFloorSlab{

     isFireResistantStructure(FloorSlab) = TRUE

}

     Wall myWall{

     isFireResistantStructure(Wall) = TRUE

}

     Object  myElement{

          getObject(Platform.Object) - getObject(Opening)

     }

     isPartitioned(myElement, , myFloorSlab) = TRUE

     isPartitioned(myElement, , myWall) = TRUE

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호 나목
check(REFB_30_0_1_나){
      KS
}
KS{
     isConnectedTo(Platform, Floor.One.Space) = TRUE
     Door myDoor{
     isObjectProperty(Door.isEntrance) = TRUE
     isInstalled(Door, Floor.One) = TRUE
     }
     isObjectProperty(myDoor.isStrictFireproofDoor) = TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호 다목

check(REFB_30_0_1_다){

      KS

}

KS{

     isObjectProperty(Space.InteriorFinish.Material.nonCombustibility)=TRUE

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호 마목

Check(REFB_30_0_1_마){
      KS
}

KS{
     
        EC= getObjectCount(myElevator)  
        getFloorArea(myElevator.Platform)>=6*EC m2
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호 아목



Check(REFB_30_0_1_아){

     IF !CS THEN KS

}



CS{

   isExist(SmokeExhaustionSystem)=True

   getResult(Unimplemented_EDIMSFA_*5_0_5_가)=True

}



KS{

    getResult(RFB_14_1)=True

    getResult(RFB_14_2)=True

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 2호
check(REFB_30_0_2){
      KS
}
KS{
     getResult(REFB_30_0_2_가) = TRUE
     getResult(REFB_30_0_2_나) = TRUE
     getResult(REFB_30_0_2_다) = TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 2호 가목



Check(REFB_30_0_2_가){

      KS

}



KS{

          isFireResistantStructure(ElevatorShaft)  =True

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 2호 나목



Check(REFB_30_0_2_나){

      KS

}



KS{

   Floor myFloor{

     isObjectProperty(Floor.isEscape)=True

   }

   

ElevatorShaft myElevatorShaft1{
     hasObject(Floor,ElevatorShaft)=TRUE
}
ElevatorShaft myElevatorShaft2{
     hasObject(myFloor,ElevatorShaft)=TRUE     


isConnectedTo(myElevatorShaf1t, myElevatorShaft2, SingleStructure)=TRUE


}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 2호 다목
check(REFB_30_0_2_다){
      KS
}
KS{
     isInstalled(Opening.TopSurface, SmokeExhaustionSystem)
     getResult(RFB_14) = TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 3호
check(REFB_30_0_3){
      KS
}
KS{
     getResult(REFB_30_0_3_가) = TRUE
     getResult(REFB_30_0_3_나) = TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 3호 가목

check(REFB_30_0_3_가){

      KS

}

KS{

     FloorSlab myFloorSlab{

     isFireResistantStructure(FloorSlab) = TRUE

}

     Wall myWall{

     isFireResistantStructure(Wall) = TRUE

}

     Door myDoor{

     isObjectProperty(Door.isEntrance) = TRUE

     }

     Object myElement{

          getObject(Space.Object) - getObject(myDoor)

     }

     isPartitioned(myElement, , myFloorSlab) = TRUE

     isPartitioned(myElement, , myWall) = TRUE

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 3호 나목
check(REFB_30_0_3_나){
      KS
}
KS{
     Door myDoor{
     isObjectProperty(Door.isEntrance) = TRUE
     }
     isObjectProperty(myDoor.isStrictFireproofDoor) = TRUE
}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조 (직통계단의 설치기준) 1항

Check(REFB_8_1){

        Stair myStair{

             isObjectProperty(Stair.isDirect)=TRUE  

        }



        Passage myPassage{

             isConnectedTo(Room, Passage)=TRUE

        }



     isExist(myPassage)=TRUE

        isConnectedTo(myStair,myPassage)=TRUE

}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조 (직통계단의 설치기준) 2항



Check(REFB_8_2){

getObjectProperty(Building.usage)=“Factory.SemiconductorAndDisplayPanelManufacturingFactory＂

}

// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (피난안전구역의 설치기준) 1항
check(REFB_8-2_1){
     KS1 AND IF CS THEN KS2
}

     Zone myZone{
          isObjectProperty(Zone.isEgressSafetyZone) = TRUE
     }

     Space mySpace{
          hasSpace(Space, FacilitiesOfABuilding)
     }

     Structure myStructure{
          isObjectProperty(Space.isfireResistantStructure) = TRUE
     }

KS1{
      BSC = getBuildingStoriesCount()
     getFloorNumber(myZone) <= BSC
}

CS{
     getFloorNumber(mySpace) = getFloorNumber(myZone)
}

KS2{
     isPartitioned(myZone, myStructure, mySpace) = TRUE
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (피난안전구역의 설치기준) 2항

Check(REFB_8-2_2){



   Zone myZone{

      isObjectProperty(Zone.isEgressSafetyZone)=TRUE

   }

   Stair myStair{

      isObjectProperty(Stair.isSpecialEscape)=TRUE

      isAccessible(myZone, Stair)=TRUE

   }

  Floor myFloor{

         Floor.number>getFloorNumber(myZone)

         OR Floor.number

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (피난안전구역의 설치기준) 3항
Check(REFB_8-2_3){
 
   getResult(REFB_8-2_3_2)=TRUE
   getResult(REFB_8-2_3_3)=TRUE
   getResult(REFB_8-2_3_4)=TRUE
   getResult(REFB_8-2_3_5)=TRUE
   getResult(REFB_8-2_3_6)=TRUE
   getResult(REFB_8-2_3_7)=TRUE
   getResult(REFB_8-2_3_8)=TRUE
   getResult(REFB_8-2_3_9)=TRUE
} 


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항2호
check(REFB_8-2_3_2){

    Zone myZone{
      isObjectProperty(Zone.isEgressSafetyZone)=TRUE
   }

    isObjectProperty(myZone.InteriorFinish.nonCombustibility)=TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항3호
check(REFB_8-2_3_3){
   
  Stair myStair{
     isExternal(Stair)=FALSE
     isAccessible(myZone, Stair)=TRUE
  }
  isObjectProperty(Stair.isSpecialEscape)=TRUE
  
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항4호
check(REFB_8-2_3_4){
   
   Elevator  myElevator{
     isObjectProperty(Elevator.isEmergency)=TRUE
   }

   isDirectlyAccessible(myZone, myElevator)=TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항5호
check(REFB_8-2_3_5){
  hasObject(myZone,Hydrant)=True
  hasObject(myZone,LightingSystem)=TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항6호
check(REFB_8-2_3_6){
hasObject(myZone, WarningAndCommunicationFacility)=TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항7호
check(REFB_8-2_3_7){
    getResult(REFB_*_1-2)=TRUE
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항8호
check(REFB_8-2_3_8){
   getSpaceHeight(myZone)>=2.1 m 
}


// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (직통계단의 설치기준) 3항9호
check(REFB_8-2_3_9){

   isExist(SmokeExhaustionSystem)=TRUE
   getResult(RFB_14_2)=TRUE
   getResult(RFB_14_2_1)=TRUE
   getResult(RFB_14_2_4)=TRUE
}

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 1항

Check(REFB_9_1){

     IF (CS1) THEN KS1 ELSE IF (CS2) THEN KS2

CS1{

     Floor myFloor1 {

               Floor.number > 5

               OR Floor.number <= -2

               }

     Stair myStair1 {

          isObjectProperty(Stair.isDirect) = TRUE

     }

            Floor myFloor2 {

                           isObjectProperty(Floor.isEscape)= TRUE

            }



     isGoThrough(myFloor1, myStair1, myFloor2)= TRUE

     OR isGoThrough(myFloor1, myStair1, Ground) = TRUE

}



CS2{     

     Floor myFloor3 {

          Floor.number >= 5

     }

     

     Stair myStair3 {

          isObjectProperty(Stair.isDirect) = TRUE

           (isGoThrough(myFloor3, myFloor2, Stair) = TRUE

          OR isGoThrough(myFloor3, Ground, Stair) = TRUE)

          }

     Stair myStair2 {

          Stair.Floor.number = -1

          }



     isDirectlyAccessible(myStair2, myStair3)=TRUE

          

KS1 {     

     (isObjectProperty(myStair1.isEscape) = TRUE

     OR isObjectProperty(myStair1.isSpecialEscape) = TRUE)

     }

KS2{

       (isObjectProperty(myStair2.isEscape) = TRUE

     OR isObjectProperty(myStair2.isSpecialEscape) = TRUE)

        (isObjectProperty(myStair3.isEscape) = TRUE

     OR isObjectProperty(myStair3.isSpecialEscape) = TRUE)

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항
check (REFB_9_2){
     getResult(REFB_9_2_1) = TRUE 
     getResult(REFB_9_2_2) = TRUE
     getResult(REFB_9_2_3) = TRUE
     
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호
check(REFB_9_2_1){
     KS
}
KS{
getResult(REFB_9_2_1_1) = TRUE
getResult(REFB_9_2_1_2) = TRUE
getResult(REFB_9_2_1_4) = TRUE
getResult(REFB_9_2_1_5) = TRUE
getResult(REFB_9_2_1_6) = TRUE    
getResult(REFB_9_2_1_7) = TRUE
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 가목
check(REFB_9_2_1_1){
     KS
}
KS{
Wall myWall{
     hasElement(Stair.Space, Wall) = TRUE
     hasElement(Wall, Window) = FALSE
     hasElement(Wall, Door) = FALSE
     hasElement(Wall, Opening) = FALSE
}
Stair myStair{
            isObjectProperty(Stair.isEscape)= TRUE
}

isFireResistantStructure(myWall)= TRUE
isPartitioned (myStair, 0, myWall) = TRUE
      
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 나목

check(REFB_9_2_1_2){

     KS

}

KS{

    isObjectProperty(Stair.Space.InteriorFinish.Material.nonCombustibility) = TRUE



}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 라목

check(REFB_9_2_1_4){

IF (CS1 AND CS2) THEN KS

}

CS1 {

Opening myOpening1{

     isConnectedTo(Stair.Space, Opening) = TRUE

     getObjectProperty(Opening.material)= “WireContainedGlass”

     getObjectProperty(Window.panelOperationType)= “FixedSashWindow”

     getObjectProperty(Opening.area)=< 1㎡     

}

CS2 {

Opening myOpening2{

     getObject(Opening) != myOpening1      

}

KS{

getElementDistance(myOpening1, myOpening2, a)>=2m;     

}



}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 마목
check(REFB_9_2_1_5){
     KS
}
KS{

Opening myOpening3{
     getObject(Opening)!= Door
     isConnectedToExternal(Opening) = FALSE
     hasElement(Stair.Space, Opening) = TRUE
}

     getObjectProperty(myOpening3.material)= “WireContainedGlass”
     getObjectProperty(myOpening3.type)= “FixedSashWindow”
     getObjectProperty(myOpening3.area)=< 1㎡
     
}    



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 바목

Check(REFB_9_2_1_6){

     KS

}

KS {

     Door myDoor{

     isConnectedToExternal(Opening) = FALSE

}

     Space mySpace{

          isExternal(Space)=FALSE

}

     isGoThrough(mySpace,myDoor,Stair.Space.) = TRUE

     isObjectProperty(Door.effectiveWidth) >= 0.9m

     isEgressDirection(Door) = TRUE;



}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 사목
Check(REFB_9_2_1_7){
KS
}
KS {
Floor myFloor {
     isObjectProperty(Floor.isEscape) = TRUE
}

isFireResistantStructure(Stair) = TRUE
(isDirectlyAccessible(Stair,myFloor)= TRUE 
OR isDirectlyAccessible(Stair,Ground) = TRUE) 
 }






//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 2호

Check(REFB_9_2_2){

    IF (CS) THEN KS 

}



CS{

isExternal(Stair) = TRUE

isObjectProperty(Stair.isEscape) = TRUE

}

KS{

     getResult(REFB_9_2_2_1)=TRUE

     getResult(REFB_9_2_2_2)=TRUE

     getResult(REFB_9_2_2_3)=TRUE

     getResult(REFB_9_2_2_4)=TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 2호 가목

check(REFB_9_2_2_1){

    IF (CS) THEN KS

}





CS {

Opening myOpening1{               getObjectProperty(Opening.material)= “WireContainedGlass”

     getObjectProperty(Window.panelOperationType)= “FixedSashWindow”

     getObjectProperty(Opening.area)=< 1㎡     

}

Door myDoor {

     isAccessible(Stair, Door)=TRUE

}

Opening myOpening2{

     getObject(Opening) != myOpening1 

     getObject(Opening) != myDoor     

}

isExist(myOpening2) = TRUE

}



KS{

getElementDistance(Stair, myOpening2, a)>=2m;     

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 2호 나목
check(REFB_9_2_2_2){
     IF (CS) THEN KS     
}
CS {
     Space mySpace{
          isExternal(Space)=FALSE
}
     Door myDoor{
          isGoThrough(mySpace,Door,Stair) = TRUE
}
isExist(myDoor) = TRUE
}

KS {
     isObjectProperty(myDoor.strictFireproofDoor) = TRUE
     
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 2호 다목
check(REFB_9_2_3){
     KS     
}
KS {
     getObjectProperty(Stair.effectiveWidth)>= 0.9m
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 2호 라목

check(REFB_9_2_2_4){

     KS     

}

KS {

     isObjectProperty(Stair.isFireResistantStructure) = TRUE

     isAccessible(Stair, Ground)= TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호
check (REFB_9_2_3){
IF (CS) THEN KS 
}
CS{
isObjectProperty(Stair.isSpecialEscape) = TRUE
}
KS{
     getResult(REFB_9_2_3_1)=TRUE
     getResult(REFB_9_2_3_2)=TRUE
     getResult(REFB_9_2_3_3)=TRUE
     getResult(REFB_9_2_3_5)=TRUE
     getResult(REFB_9_2_3_6)=TRUE
     getResult(REFB_9_2_3_7)=TRUE
     getResult(REFB_9_2_3_8)=TRUE
     getResult(REFB_9_2_3_9)=TRUE
     getResult(REFB_9_2_3_10)=TRUE
     getResult(REFB_9_2_3_11)=TRUE
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 가목

check (REFB_9_2_3_1){

CS THEN KS 

}

CS {

isExist(Stair.Space) = TRUE

}

KS {

     Window myWindow {

          getObjectProperty(Window.area)>= 1 m2

          isObjectProperty(Window.isExternalDirection) = TRUE

           getElementDistance(Window, FloorSlab, a)>=1m



}

     SmokeExhaustionSystem mySmokeExhaustionSystem {

          getElement(SmokeExhaustionSystem)

          getResult(RFB_14)=TRUE

}



     Space mySpace1{

          getSpace(“Balcony”)

}

     Space mySpace2{

          isExternal(Space)=FALSE

}

     Space mySpace3{

          getSpace(“AncillaryRoom”)

          getFloorArea(Space.Floor, ) >= 3㎡

          hasElement(Space,mySmokeExhaustionSystem) = TRUE

          hasElement(Space,myWindow) = TRUE

}

isGoThrough(mySpace2,Stair.Space, ,mySpace1)

OR isGoThrough(mySpace2,Stair.Space, ,mySpace3)


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 나목
check (REFB_9_2_3_2){
IF (CS) TEHN KS
}

CS{
     Space mySpace {
          getSpace(Stair.Space)
          getSpace(“Balcony”)
          getSpace(“AncillaryRoom”)
}
isExist(mySpace)=TRUE
}

KS{
   Wall myWall {
getObjectProperty(Wall.isFireResistantStructure = TRUE
}
   isPartitioned(mySpace, 0, myWall)= TRUE
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 다목
check (REFB_9_2_3_3){
CS TEHN KS
}

CS{
     Space mySpace {
          getSpace(Stair.Space)
          getSpace(“AncillaryRoom”)
}
isExist(mySpace)=TRUE
}

KS{
   
}



//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 마목

check (REFB_9_2_3_5){

CS TEHN KS

}

CS{

     Space mySpace {

          getSpace(Stair.Space)

          getSpace(“Balcony”)

          getSpace(“AncillaryRoom”)

}

     Opening myOpening1 {

          hasElement(mySpace,Opening)=TRUE

          isConnectedToExternal(Opening) = TRUE



     Opening myOpening2 {

          getObjectProperty(Opening.material)= “WireContainedGlass”

          getObjectProperty(Window.panelOperationType)= “FixedSashWindow”

          getObjectProperty(Opening.area)=< 1㎡

}

     Opening myOpening3{

          getObject(myOpening1)-getObject(myOpening2)

}

isExist(myOpening3)=TRUE



KS{

     Opening myOpening4{

          getObject(Opening)-getObject(myOpening3)

}

getElementDistance(myOpening3, myOpening4, a)>=2m

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 바목

check (REFB_9_2_3_6){

CS TEHN KS

}

CS{

isExist(Stair.Space)=TRUE

KS{

      Space mySpace1{

          getSpace(“Balcony”)

          getSpace(“AncillaryRoom”)

          hasObject(Stair.Space, Space)=TRUE

}

     Space mySpace2{

          isExternal(Space)=FALSE

}

     Opening myOpening {

          getObject(Stair.Space.Opening) + getObject(mySpace2.Opening) + getObject(mySpace1.Opening)

}

hasSpace(Stair.Space, myOpening) = TRUE


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 사목

check (REFB_9_2_3_7){

CS TEHN KS

}

CS{

     Space mySpace {

          getSpace(“Balcony”)

          getSpace(“AncillaryRoom”)

          hasObject(Stair.Space,Space)=TRUE

}

     Opening myOpening {

          getObject(mySpace.Opening)

}

isExist(myOpening)=TRUE

}



KS{

getObjectProperty(myOpening.material)= “WireContainedGlass”

getObjectProperty(Window.panelOperationType)= “FixedSashWindow”

getObjectProperty(myOpening.area)=< 1㎡

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 아목

check (REFB_9_2_3_8){

IF (CS) TEHN KS

}

CS{

     Space mySpace1 {

          getSpace(“Balcony”)

          getSpace(“AncillaryRoom”)

}

isExist(mySpace1)=TRUE

}

KS{

     Space mySpace2{

          isExternal(Space)=FALSE

}

     Opening myOpening {

           getObject(mySpace2.Opening)
getObject(Stair.Space.Opening)

}

hasSpace(mySpace1,myOpening)= FALSE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 자목

check (REFB_9_2_3_9){

IF(CS1) THEN KS1 OR (CS2) TEHN KS2

}

Space mySpace1 {

     isExternal(Space)=FALSE

}

Space mySpace2 = getSpace(“Balcony”) + getSpace(“AncillaryRoom”)

CS1{

     

     isGoThrough(mySpace1,Door,mySpace2) = TRUE

}

KS1 {

     isObjectProperty(Door.isStrictFireproofDoor)= TRUE

}



CS2{

     isGoThrough(mySpace2,Door,Stair.Space) = TRUE

}

KS2{

     isObjectProperty(Door.isFireproofDoor)= TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 차목

check (REFB_9_2_3_10){

     KS

}

KS{

     Floor myFloor {

          isObjectProperty(Floor.isEscape) =TRUE

     isObjectProperty(Stair.isFireResistantStructure) = TRUE

     isAccessible(Stair,myFloor)=TRUE

     OR isAccessible(Stair,Ground)=TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 카목

check (REFB_9_2_3_카){
     KS
}

KS{
getObjectProperty(Door.effectiveWidth) >= 0.9m
isObjectProperty(Door.isEscapeDirection)=TRUE
}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 3항

Check(REFB_9_3) {

     KS

}

KS {

     Stair myStair1{

          isObjectProperty(Stair.isEscape)=TRUE

          OR isObjectProperty(Stair.isSpecialEscape)=TRUE

}

     Space mySpace{

          getObjectProperty(Space.usage) = “RooftopPlaza”
}
          hasObject(Rooftop, mySpace)=TRUE



}

     Stair myStair2{

          hasObject(mySpace.Building,myStair1)=TRUE 

}     

     getObjectProperty(myStair.type)!= “WindingStair”

     isAccessible(myStair2,mySpace)=TRUE

     isEgressDirection(mySpace.Door) = TRUE

}


//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 4항
Check(REFB_9_4) {
     KS
}
     Building myBuilding{
          Building.usage = “SideCorridorTypeMultiUnitHouse”
}

     Space mySpace = getSpace(“Corridor”)
     isConnectedToExternal(mySpace)=TRUE

//건축법 47조 (건축선에 따른 건축제한) 1항

Check(BA_47_1){
      KS
}

KS{
    Floor myFloor{
        Floor.number>0
    }
     isOverBldAlignment(myFloor)=False
}


//건축법 47조 (건축선에 따른 건축제한) 2항

Check(BA_47_2){
     KS
}

KS{
    Floor myFloor{
          getVerticleDistance(Floor, "도로면" )<=4.5
    }
    isOverBldAlignment(myFloor, 1)=False
}

//건축법 49조 (건축물의 피난시설 및 용도제한 등) 1항
Check(BA_49_1){
   IF CS THEN KS 
}

CS{
  getResult(EDBA_34_2)= TRUE
  OR getResult(EDBA_35_1) = TRUE
  OR getResuLt(EDBA_35_2) = TRUE
  OR getResuLt(EDBA_35_3) = TRUE
  OR getResuLt(EDBA_35_5) = TRUE
  OR getResult (EDBA_38) = TRUE
  OR getResuLt(EDBA_39_1) = TRUE
  OR getResuLt(EDBA_39_2) = TRUE
}

KS{

Door myDoor{
isObjectProperty(Door.isEntrance)=TRUE
}

   isExist(Corridor) = TRUE
   isExist(Stair) = TRUE
   isExist(myDoor) = TRUE
   isExist(EvacuationFacility) = TRUE
   isExist(FireHydrant) = TRUE
   isExist(Tank) = TRUE
   isExist(ExtinguishingSystem)= TRUE
   isExist(Passage)=True

   getResult(REFB_11_1)= TRUE
   getResult(REFB_11_2)= TRUE
   getResult(REFB_11_3)= TRUE
   getResult(REFB_11_4)= TRUE
   getResult(REFB_11_5)= TRUE
}


//건축법 49조 (건축물의 피난시설 및 용도제한 등) 2항
Check(BA_49_2){
     IF CS THEN KS
}

CS{
    getResult(EDBA_34_1)= TRUE
    OR getResult(EDBA_34_3)= TRUE
    OR getResult(EDBA_34_4)= TRUE
    OR getResult(EDBA_46_1)= TRUE
    OR getResult(EDBA_46_2)= TRUE
    OR getResult(EDBA_46_3)= TRUE
    OR getResult(EDBA_46_4)= TRUE
    OR getResult(EDBA_46_5)= TRUE
    OR getResult(EDBA_47_1)= TRUE 
    OR getResult(EDBA_47_2)= TRUE
    OR getResult(EDBA_48_1)= TRUE 
    OR getResult(EDBA_48_2)= TRUE
    OR getResult(EDBA_50)= TRUE 
    OR getResult(EDBA_51_1)= TRUE 
    OR getResult(EDBA_51_2)= TRUE
    OR getResult(EDBA_51_3)= TRUE  
    OR getResult(EDBA_52)= TRUE
}

KS{
   getResult(REFB_3)= TRUE 
   AND getResult(REFB_4)= TRUE
   AND getResult(REFB_8)= TRUE
   AND getResult(REFB_9)= TRUE 
   AND getResult(REFB_10)= TRUE
   AND getResult(REFB_11)= TRUE
   AND getResult(REFB_14)= TRUE
   AND getResult(REFB_15)= TRUE 
   AND getResult(REFB_16)= TRUE
   AND getResult(REFB_17)= TRUE
   AND getResult(REFB_18)= TRUE
}


//건축법 49조 (건축물의 피난시설 및 용도제한 등) 3항 

Check(BA_49_3){
   KS
}

KS{
   getResult(EDBA_53_1)=True
   getResult(EDBA_53_2)=True
}

//건축법 50조 (건축물의 내화구조와 방화벽) 1항
check(BA_50_1){
     getResult(EDBA_56_1) = TRUE
     getResult(EDBA_56_2) = TRUE
     isObjectProperty(MainStructuralPart.isFireResistantStructure) = TRUE
}

//건축법 51조 (방화지구 안의 건축물) 1항 

Check(BA_51_1){
   IF (!CS1 AND CS2) THEN KS
}

CS1{
    getResult(EDBA_58)=True
}

CS2{
    getResult(LPUA_37_1_4)=True
}

KS{

   Wall myWall{
     isObjectProperty(Wall.isExternal)=True
   }

        isFireResistantStructure(MainStructure) = TRUE
        isFireResistantStructure(myWall) = TRUE
}





//건축법 51조 (방화지구 안의 건축물) 2항



Check(BA_51_2){

       IF CS THEN KS 

}



CS{

   getResult(LPUA_37_1_4)=True

   

}



KS{



   Construction  myConstruction {

       

       isInstalled(Construction , Rooftop)=True

       OR Construction.height>=3 m 

   }



   isObjectProperty(myConstruction.MainStructuralPart.Material.nonCombustibility)=True

}


//건축법 51조 (방화지구 안의 건축물) 3항

Check(BA_51_3){
    KS
}

KS{
   getResult(REFB_23_1)=True
   getResult(REFB_23_2)=True
}

//건축법 52조 (건축물의 마감재료) 1항
Check(BA_52_1){
   IF CS THEN KS 
}

Building myBuilding{
getResult(EDBA_61_1)=TRUE
}
CS{
isExist(myBuilding)=TRUE
}
KS{
getResult(REFB_24_1)=TRUE
getResult(REFB_24_2)=TRUE
getResult(REFB_24_3)=TRUE
getResult(REFB_24_4)=TRUE
}


//건축법 52조 (건축물의 마감재료) 2항

Check(BA_52_2){
IF CS THEN KS
}

CS{
getResult(EDBA_61_2)=TRUE
}
KS{
getResult(REFB_24_5)=TRUE

}





//건축법 52조 (건축물의 마감재료) 3항
Check(BA_52_3){

}

// 비대상?

Check(BA_53){

IF (CS) THEN KS END IF

}



CS{

   Space.Floor.number<0 ;

}



KS{

   getResult(REFB_25_1)=True

}

//     건축법 55조 (건축물의 건폐율)
Check(BA_55){
     IF CS THEN KS
}

KS{
     getResult(LPUA_77_1) = TRUE
     getResult(LPUA_77_2) = TRUE
     getResult(LPUA_77_3) = TRUE
}

//건축법 56조 (건축물의 용적률)

Check(BA_56){
KS
}

KS{

getResult(LPUA_78)= TRUE

}

//건축법 64조 (승강기) 1항
check(BA_64_1){
   IF CS THEN KS
}

CS{ 
   getBuildingStoriesCount() >= 6    
   getGrossFloorArea()>= 2000 m2
}

KS{
     isExist(Elevator) = TRUE
        getResult(RFB_5)=TRUE
        getResult(RFB_6)=TRUE
        getResult(REFB_29_1)=True
}


//건축법 64조 (승강기) 2항

check(BA_64_2){

  IF (!CS1 AND CS2) THEN KS

}



CS1{

    getResult(RFB_9)=TRUE

} 



CS2{

    getBuildingHeight()>31 m

}

KS{


   getResult(BA_64_1) = TRUE 

   isObjectProperty(Elevator.isEmergency)= TRUE

   getResult(EDBA_90_1)=TRUE

   getResult(RFB_10)=TRUE

}

// 건축법 시행령 34조 (직통계단의 설치) 1항

Check(EDBA_34_1){
     KS
}

KS{
Floor myFloor{
      isObjectProperty(Floor.isEscape) = TRUE
}

Space mySpace{
      getObjectProperty(Space.usage)="PerformanceHall"
      OR getObjectProperty(Space.usage)="AssemblyHall"
      OR getObjectProperty(Space.usage)="Auditorium"     
      OR getObjectProperty(Space.usage)="ExhibitionHall"
}

Door myDoor{
     isDirectlyAccessible(Door, Ground)=TRUE
}

Stair myStair{
     isObjectProperty(Stair.isDirect)=TRUE
     isAccessible(Stair,myFloor)=TRUE
     OR isAccessible(Stair,Ground)=TRUE
}

Ramp myRamp{
     isAccessible(Ramp,myFloor)=TRUE
     OR isAccessible(Ramp,Ground)=TRUE
}

Floor myFloor2{
     isObjectProperty(Floor.isEscape)=FALSE
     OR hasObject(Floor, myDoor)=FALSE
}

     Zone myZone{

          isDirectlyAccessible(myStair, Zone)=FALSE

     }

 

IF

     getFloorNumber(mySpace)>0

     getFloorArea(mySpace)<=300 m2

     isFireResistantStructure(MainStructuralPart)=TRUE

     OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE 

     THEN IF        getBuildingStoriesCount()>=16

                    getBuildingUsage()="MultiUnitHouse"

               THEN ED= 40 

     ELSE THEN   ED=50               

     END IF



ELSE IF   

     getBuildingUsage() = "Factory" 

     isExist(ExtinguishingSystem)=TRUE 

     isObjectProperty(ExtinguishingSystem.isAutomatic)=TRUE

     getResult(REFB_8_2)=TRUE

     THEN IF        getBuildingUsage() = "UnmannedFactory" 

               THEN ED=100

     ELSE THEN  ED=75

     END IF 



ELSE THEN ED=30

     END IF 



     (hasObject(myFloor,myStair)=TRUE

     hasObject(myZone, myStair)=TRUE

     getObjectDistance(Room,myStair, 1)<=ED)

     OR 

     (hasObject(myFloor,myRamp)=TRUE

     hasObject(myZone, myRamp)=TRUE

     getObjectDistance(Room,myRamp, 1)<=ED)

}


//건축법 시행령 34조 (직통계단의 설치) 2항

Check(EDBA_34_2){

   IF (CS1 AND CS2) THEN KS

}



CS1{

     isObjectProperty(Floor.isEscape) = FALSE

}



CS2{

     getResult(EDBA_34_2_1)=TRUE

        OR getResult(EDBA_34_2_2)=TRUE

        OR getResult(EDBA_34_2_3)=TRUE  

        OR getResult(EDBA_34_2_4)=TRUE

        OR getResult(EDBA_34_2_5)=TRUE

}



KS{

        Floor myFloor{

        isObjectProperty(Floor.isEscape)=TRUE

        }



        Stair myStair{

                isObjectProperty(Stair.isDirect) = TRUE

                isAccessible(myFloor, Stair)= TRUE

                OR isAccessible(Ground,Stair) = TRUE

        }



        getObjectCount(myStair)>2 

        getResult(REFB_8_1) = True

}


//건축법 시행령 34조 (직통계단의 설치) 2항1호

Check(EDBA_34_2_1){

KS

}

KS{

Floor myFloor1{

       getObjectUsage(Floor) ="ClassIINeighborhoodLivingFacility.PerformanceHall"

       OR  getObjectUsage(Floor)="ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"

}



Floor myFloor2 {

       getObjectUsage(Floor)="CulturalAndAssemblyFacility"

       getObjectUsage(Floor) != "CulturalAndAssemblyFacility.ExhibitionHall"          

       getObjectUsage(Floor) != "CulturalAndAssemblyFacility.ZoologicalAndBotanicalGarden“

          

       getObjectUsage(Floor) = "ReligiousFacility"

       getObjectUsage(Floor) = “AmusementFacility.BarBusiness"

       getObjectUsage(Floor) = “AmusementFacility.FuneralParlors“

}



      getTotalFloorArea(myFloor1.Space)>=300 m2

         OR getTotalFloorArea(myFloor2.Space)>=200 m2

        

}


//건축법 시행령 34조 (직통계단의 설치) 2항2호

Check(EDBA_34_2_2){



        Building myBuilding{

              getBuildingUsage()="DentalClinic"

        }


Space mySpace{
getSpaceUsage() = "Ward"
}
     Floor myFloor1 {

          getObjectProperty(Floor.number)>=3

                getObjectUsage(Floor)  = “DetachedHouse.MultiUserHouse”

          OR getObjectUsage(Floor)  = “DetachedHouse.MultiFamilyHouse”

          OR getObjectUsage(Floor)  = “ClassIINeighborhoodLivingFacility.EducationalInstitute”

          OR getObjectUsage(Floor)  = “ClassIINeighborhoodLivingFacility.ReadingRooms” 

                OR getObjectUsage(Floor)  = “CommercialFacility”

                OR getObjectUsage(Floor)  = “TransportationFacility.PassengerTrafficFacilities”

                OR ( getObjectUsage(Floor)  = “MedicalFacility” ADN hasObject(myBuilding, mySpace)=TRUE )

                OR getObjectUsage(Floor)  = “EducationAndResearchFacility.EducationalInstitutes” 

          OR getObjectUsage(Floor)  = “FacilitiesForTheAgedAndChildren.ChildrenRelatedFacilities” 

          OR getObjectUsage(Floor)  = “EducationAndResearchFacility.WelfareFacilityForTheAged” 

          OR getObjectUsage(Floor)  = “Trainingfacility.YouthHostel” 

          OR getObjectUsage(Floor)  = “LodgingFacility”

                

     }



     Floor myFloor2{

           getObjectUsage(Floor)  = “ClassIINeighborhoodLivingFacility.FacilityForProvidingInternetComputerGameService”

          }



           getTotalFloorArea(myFloor1.Room)>= 200 m2

          OR getTotalFloorArea(myFloor2.Room)>= 300 m2     

}


//건축법 시행령 34조 (직통계단의 설치) 2항3호

Check(EDBA_34_2_3){



     Floor myFloor{

           getFloorUsage()= “MultiUnitHouse”

          getObjectProperty(Floor.numberOfHousehold)>=4 



          OR getFloorUsage() = “BusinessFacility.Officetel”

     }     



                    getTotalFloorArea(myFloor.Room)>=300 m2



}


//건축법 시행령 34조 (직통계단의 설치) 2항4호
check(EDBA_34_2_4){

     IF getResult(EDBA_34_2_1)=FALSE
        OR getResult(EDBA_34_2_2)=FALSE
     OR getResult(EDBA_34_2_3)=FALSE
        THEN getTotalFloorNumber(myFloor.Room)>=400 m2
     END IF
}


//건축법 시행령 34조 (직통계단의 설치) 2항5호
check(EDBA_34_2_5){
     Floor myFloor {
          getFloorNumber()<0
     }
          
     getTotalFloorArea(myFloor.Room)>= 200 m2
}



// 건축법 시행령 제 34조 (직통계단의 설치) 3항

check(EDBA_34_3){

          IF CS THEN KS ENDIF

}



CS{

isObjectProperty(Building.isHighriseBuilding) = TRUE

}

KS{

          Stair myStair{

                    isObjectProperty(Stair.isDirect) = TRUE               

          }

          Zone myZone{

                    isObjectProperty(Zone.isEgressSafetyZone) = TRUE

          }

          Floor myFloor{

                    isObjectProperty(Floor.isEscape) = TRUE

          }

isGoThrough(myFloor, myZone, myStair) = TRUE

          OR isGoThrough(myFloor, Ground, myStair) = TRUE



          getObjectCount(myZone) >= getBuildingStoriesCount()/30

}


// 건축법 시행령 34조 (직통계단의 설치) 4항

check(EDBA_34_4){

          IF !CS THEN KS ENDIF

}

CS{

          Stair myStair{

                    isObjectProperty(Stair.isDirect) = TRUE

          }

          Floor myFloor{

                    isObjectProperty(Floor.isEscape) = TRUE

          }

          isDirectlyAccessible(myStair, myFloor) = TRUE

          OR isDirectlyAccessible(myStair, Ground) = TRUE

}

                    

KS{

          isObjectProperty(Building.isQuasiHighriseBuilding) = TRUE

          Stair myStair{

                    isObjectProperty(Stair.isDirect) = TRUE               

          }

          Zone myZone{

                    isObjectProperty(Zone.isEgressSafetyZone) = TRUE

          }

          Floor myFloor{

                    isObjectProperty(Floor.isEscape) = TRUE

          }

                isGoThrough(myFloor, myZone, myStair) = TRUE

          OR isGoThrough(myFloor, Ground, myStair) = TRUE

          (getBuildingStoriesCount()/2)-5 < getFloorNumber(myZone)

                getFloorNumber(myZone) < (getBuildingStoriesCount()/2)+5

}


// 건축법 시행령 34조 (직통계단의 설치) 5항
check(EDBA_34_5){
          getResult(REFB_8_1) = TRUE
          getResult(REFB_8-2_1) = TRUE
          getResult(REFB_8-2_2) = TRUE
          getResult(REFB_8-2_3) = TRUE
}

//건축법 시행령 35조(피난계단의 설치) 1항
Check(EDBA_35_1){
     IF (!CS1 AND !CS2 AND CS3) THEN KS
}

CS1 {
     isFireProofStructure(MainStructuralPart) = TRUE
     OR isObjectProperty(MainStructuralPart.Material.nonCombustibility) = TRUE
}

CS2 {
     getResult(EDBA_35_1_1) = TRUE
     OR getResult(EDBA_35_1_2) = TRUE
}

CS3{
     Floor myFloor {
          Floor.number > 5
          OR Floor.number <= -2
     }

     Stair myStair {     
          isObjectProperty(Stair.isDirect) = TRUE
     }

     hasElement(myFloor, myStair) = TRUE
}

KS {
     isObjectProperty(myStair.isEscape) = TRUE
     OR isObjectProperty(myStair.isSpecialEscape) = TRUE
}


//건축법 시행령 35조(피난계단의 설치) 1항1호

Check(EDBA_35_1_1){
     KS
}



KS { 
     Floor myFloor { 
     getObjectProperty(Floor.number) >= 5 
     } 

     getTotalFloorArea(myFloor) <= 200m2 

}


//건축법 시행령 35조(피난계단의 설치) 1항2호

Check(EDBA_35_1_2){

     KS

}



KS { 

     Floor myFloor { 

           Floor.number >= 5 

     } 



     isFirePartition(myFloor, a, 200) = TRUE 

}


//건축법 시행령 35조 (피난계단의 설치) 2항
check(EDBA_35_2){
     IF (CS1 AND CS2) THEN KS
}

CS1{
     Building.usage != "MultiUnitHouse.SideCorridorTypeMultiUnitHouse"
}

CS2{
     Floor myFloor{
           IF (Building.usage = "MultiUnitHouse“) 
               THEN getFloorNumber(Floor) >= 16
               ELSE           
               getFloorNumber(Floor) >= 11
               ENDIF

           OR getFloorNumber(Floor) < -3
          getFloorArea(Floor) >= 400m2
     }

     Stair myStair {
          (isAccessible(Stair, Floor.isEscape) = TRUE
           OR isAccessible(Stair, Ground) = TRUE)
                        isObjectProperty(Stair.isDirect) = TRUE
     }

     hasObject(myFloor, myStair) = TRUE
}

KS{
     isObjectProperty(myStair.isSpecialEscape) = TRUE
}



//건축법 시행령 35조 (피난계단의 설치) 3항
check(EDBA_35_3){
     IF (CS) THEN KS
CS{
     getResult(EDBA_35_1) = TRUE

     Floor myFloor {
          Floor.usage = “CommercialFacility”
     }

     Stair myStair{
          isObjectProperty(Stair.isDirect) = TRUE
     }

     isAccessible(myFloor, myStair) = TRUE
}

KS{
     isObjectProperty(one.myStair.isSpecialEscape) = TRUE
}



//건축법 시행령 35조 (피난계단의 설치) 5항
check(EDBA_35_5){
     IF (CS) THEN KS
}

CS{
     Floor myFloor{
          Floor.number >= 5
          OR Floor.usage = "CulturalAndAssemblyFacility.ExhibitionHall"
          OR Floor.usage = "CulturalAndAssemblyFacility.ZoologicalAndBotanicalGarden"
          OR Floor.usage = "CommercialFacility"
          OR Floor.usage = "PassengerTrafficFacilities“??
          OR Floor.usage = "SportsFacility"
          OR Floor.usage = "AmusementFacility"
          OR Floor.usage = "FacilityForTourismAndRelaxation“???
          OR Floor.usage = "Trainingfacility.TrainingFacilityInLivingZone“
     }

     isExist(myFloor)=True           
}

KS{     
     Stair myStair2{
          isObjectProperty(Stair.isSpecialEscape) = True
          OR isObjectProperty(Stair.isEscape) = True
     }

     getResult(EDBA_34) = TRUE

     IF (getTotalFloorArea(myFloor.Space) >= 2000m2)           
          THEN getObjectCount(myStair2) >= 1+ getFloorArea(myFloor.Space)/2000
}

//건축법 시행령 36조 (옥외 피난계단의 설치)

Check(EDBA_36){
    IF CS THEN KS
}

CS{
   getBuildingStoriesCount()>=3
   getResult(EDBA_36_0_1)=True
   OR getResult(EDBA_36_0_2)=True
}

KS{
   Stair myStair1{
       isObjectProperty(Stair.isDirect)=True
   }
   
   Stair myStair2{
       isObjectProperty(Stair.isEscape)=True
       isAccessible(Stair, Ground)=True
   }
  
   isExist(myStair1)=True
   isExist(myStair2)=True
}


//건축법 시행령 36조 (옥외 피난계단의 설치) 1호

Check(EDBA_36_0_1){
        KS
}

KS{
      Floor myFloor{
          getFloorUsage()="CulturalAndAssemblyFacility.PerformanceHall"
          OR getFloorUsage()="AmusementFacility.BarBusiness"
      }

      FloorSlab myFloorSlab{
           getObjectUsage(FloorSlab)="NeighborhoodLivingFacility.PerformanceHall"
      }


      getFloorUsage()="NeighborhoodLivingFacility.PerformanceHall"
      getObjectArea(myFloorSlab)>=300 m2
      OR getTotalFloorArea(myFloor.Room)>300 m2

     
}


//건축법 시행령 36조 (옥외 피난계단의 설치) 2호

Check(EDBA_36_0_2){
            KS
}

KS{   
      Floor myFloor{
           getFloorUsage()="CulturalAndAssemblyFacility.AssemblyHall"
      }

      getTotalFloorArea(myFloor.Room)>=1000 m2


}

Check(EDBA_37){

  IF (CS) THEN KS END IF

  Space mySpace{

        Space.Floor.area > 3000 M2;

        Space.usage="PerformanceHall"

        OR Space.usage="AssemblyHall"

        OR Space.usage="Auditorium"

        OR Space.usage="ExhibitionHall"

  }

}



CS{

    

    mySpace.Floor.number< 0 

    

}



KS{

Stair myStair{
Stair.isOutdoor = TRUE
}
Floor myFloor{
Floor.isEscape = TRUE
}
Space mySpace{
hasObject(Space, Ceiling) != TRUE
}
     (isGoThrough(mySpace, myStair, myFloor)=True

     OR isGoThrough(mySpace, Ramp, myFloor)=True)

     AND isExternal(mySpace)=True

    

}

//건축법 시행령 38조(관람석 등으로부터의 출구 설치)

Check(EDBA_38){

  IF (CS) THEN  KS ENDIF

}



CS{

    getResult(EDBA_38_0_1) = TRUE

    OR getResult(EDBA_38_0_2) = TRUE

    OR getResult(EDBA_38_0_3) = TRUE

    OR getResult(EDBA_38_0_4) = TRUE

    OR getResult(EDBA_38_0_5) = TRUE

}



KS {

    Space mySpace = getSpace("Auditorium")+getSpace("AssemblyHall")



    Door myExit {

        isObjectProperty(Door.isEntrance) = TRUE

        isAccessible(mySpace, Door) = TRUE

        getResult(REFB_10_1) = TRUE

    }



    hasElement(mySpace, myExit)=TRUE 

}


//건축법 시행령 38조(관람석 등으로부터의 출구 설치) 1호
Check(EDBA_38_0_1){
     (getBuildingUsage() = "ClassIINeighborhoodLivingFacility.performancehall"
     OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility")

     Space mySpace {
          getSpaceUsage(Space) = "ClassIINeighborhoodLivingFacility.performancehall"
          OR getSpaceUsage(Space) = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"
     }

     getTotalFloorArea(mySpace) > 300
}




//건축법 시행령 38조(관람석 등으로부터의 출구 설치) 2호
Check(EDBA_38_0_2){
     getBuildingUsage() = "CulturalAndAssemblyFacility
"
     getBuildingUsage() != "CulturalAndAssemblyFacility.ExhibitionHall"
     getBuildingUsage() != "CulturalAndAssemblyFacility.ZoologicalAndBotanicalGarden"

     getResult(REFB_10_2) = TRUE
}




//건축법 시행령 38조(관람석 등으로부터의 출구 설치) 3호
Check(EDBA_38_0_3){
    getBuildingUsage() = "ReligiousFacility" 
}



//건축법 시행령 38조(관람석 등으로부터의 출구 설치) 4호
Check(EDBA_38_0_4){
    getBuildingUsage() = "AmusementFacility"
}


//건축법 시행령 38조(관람석 등으로부터의 출구 설치) 3호
Check(EDBA_38_0_5){
    getBuildingUsage() = "FuneralParlor"
}

// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 

Check(EDBA_39_1){     
IF  CS THEN KS
}

CS {
getResult(EDBA_39_1_1) = TRUE
OR getResult(EDBA_39_1_2) = TRUE
OR getResult(EDBA_39_1_3) = TRUE
OR getResult(EDBA_39_1_4) = TRUE
OR getResult(EDBA_39_1_5) = TRUE
OR getResult(EDBA_39_1_6) = TRUE
OR getResult(EDBA_39_1_7) = TRUE
OR getResult(EDBA_39_1_8) = TRUE
OR getResult(EDBA_39_1_9) = TRUE
OR getResult(EDBA_39_1_10) = TRUE
}

KS {
Door myDoor{
 isObjectProperty(Door.isEntrance)=TRUE
}

isExist(myDoor)=TRUE

getResult(REFB_11_1)=TRUE
getResult(REFB_11_2)=TRUE
getResult(REFB_11_3)=TRUE
getResult(REFB_11_4)=TRUE
getResult(REFB_11_5)=TRUE
getResult(REFB_11_6)=TRUE

}




// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 1호

Check(EDBA_39_1_1){     
KS}

KS {

Building myBuilding{
getBuildingUsage() = “PerformanceHall”
OR getBuildingUsage() = “ReligiousAssemblyFacility ”
OR getBuildingUsage() = “FacilityForProvidingInternetComputerGameService”
}

Space mySpace{
Space.usage = “PerformanceHall”
OR Space.usage = “ReligiousAssemblyFacility ”
OR Space.usage = “FacilityForProvidingInternetComputerGameService”
}

IF isExist(myBuilding) THEN mySpace.FloorSlab.area >= 300 m2

}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 2호

Check(EDBA_39_1_2){     
KS
}

KS {

Building myBuilding{
getBuildingUsage() = “CulturalAndAssemblyFacility”
getBuildingUsage() != “ExhibitionHall”
getBuildingUsage() != “ZoologicalAndBotanicalGarden”
}

isExist(myBuliding) = TRUE

}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 3호

Check(EDBA_39_1_3){     
KS
}

KS {
Building myBuilding{
getBuildingUsage() = “ReligiousFacility”
}

isExist(myBuliding) = TRUE
}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 4호

Check(EDBA_39_1_4){     
KS
}

KS {
Building myBuilding{
getBuildingUsage() = “CommercialFacility”
}

isExist(myBuliding) = TRUE
}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 5호

Check(EDBA_39_1_5){     
KS
}

KS {
Building myBuilding{
getBuildingUsage() = “BusinessFacility.GovernmentOfficeBuilding”
}

isExist(myBuliding) = TRUE
}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 6호

Check(EDBA_39_1_6){     
KS
}


KS {
Building myBuilding{
getBuildingUsage() = “AmusementFacility”
}

isExist(myBuliding) = TRUE
}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 7호

Check(EDBA_39_1_7){     
KS
}


KS {
Building myBuilding{
getBuildingUsage() = “Warehouse”
Building.grossFloorArea >= 5000 m2
}

isExist(myBuliding) = TRUE
}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 8호



Check(EDBA_39_1_8){
 

KS


}







KS {

Building myBuilding{

getBuildingUsage() = “EducationAndResearchFacility.School”

}



isExist(myBuliding) = TRUE

}


// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 9호

Check(EDBA_39_1_9){     
KS}

KS {
Building myBuilding{
getBuildingUsage() = “FuneralParlor”
}

isExist(myBuliding) = TRUE
}





// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 10호

Check(EDBA_39_1_10){     
KS
}


KS {
Building myBuilding{
hasObject(Building, Elevator)
}

isExist(myBuliding) = TRUE
}



// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 2항

Check(EDBA_39_2){     
IF  CS THEN KS
}

CS {
Door myDoor {
isObjectProperty(Door.isEntrance) = TRUE
Door.panelOperationType=“RevolvingDoor”
}
isExist(myDoor) = TRUE
}

KS {
getResult(REFB_11_2)=TRUE
}

//건축법 시행령 40조 (옥상광장 등의 설치) 1항

check(EDBA_40_1){

     IF (CS) THEN KS

}



CS{

     Space myBalcony {

          getSpace(“Balconly”)

          Space.Floor.number >= 2

     }



     Space mySpace{

          getSpace(“RoofTopPlaza”) + getSpace(myBalcony)

     }



     isAccessible(mySpace) = TRUE

}



KS{

     hasElement(mySpace, Railing) = TRUE

     mySpace.Rail.height >= 1.2m

}


//건축법 시행령 40조 (옥상광장 등의 설치) 2항

Check(EDBA_40_2){

 IF (CS) THEN KS

}



CS{

     Floor myFloor{

          getObjectUsage(Floor) = “ClassIINeighborhoodLivingFacility.PerformanceHall“

          OR getObjectUsage(Floor) = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"

        OR getObjectUsage(Floor)= "ClassIINeighborhoodLivingFacility.FacilityForProvidingInternetComputerGameService“


//건축법 시행령 40조 (옥상광장 등의 설치) 3항
Check(EDBA_40_3){
  IF (CS) THEN KS 
}

CS{
     Floor myFloor{
          Floor.number > 11
     }

        getBuildingStoriesCount() > 11
        getTotalFloorArea(myFloor) > 10000m2
}

KS{
  getResult(EDBA_40_3_1) = True
  getResult(EDBA_40_3_2) = True
}



//건축법 시행령 40조 (옥상광장 등의 설치) 3항 1호

Check(EDBA_40_3_1){

  IF (CS) THEN KS

}



CS{

     getObjectProperty(Roof.shapeType) = “FlatRoof”

}



KS{

     isExist(Heliport) = True

        getResult(REFB_13_1)=True

        getResult(REFB_13_2)=True

}


//건축법 시행령 40조 (옥상광장 등의 설치) 3항 2호

Check(EDBA_40_3_2){

  IF (CS) THEN KS

}



CS{

     getObjectProperty(Roof.shapeType) = “PitchedRoof ”

}



KS{
Space mySpace{
Space.isEscape = TRUE
}
     isExist(mySpace) = True

     getObjectProperty(mySpace.Roof.shapeType) = “PitchedRoof”



        getResult(REFB_13_3)=True

        

}


//건축법 시행령 40조 (옥상광장 등의 설치) 4항
Check(EDBA_40_4){
  IF (CS1) THEN KS1 ELSE IF (CS2) THEN KS2
}
CS1{
  getResult(EDBA_40_3_1)=True
 
}
KS1{
   getResult(REFB_13_1)=True
   getResult(REFB_13_2)=True
  
}
CS2{
   getResult(EDBA_40_3_2)=True
}

KS2{
   getResult(REFB_13_3)=True
}

Check(EDBA_41_1){

    KS

}







KS{



   Door  myDoor {
getObjectProperty(Door.functionType) = "Main"
   }

   Stair myStair{
isAccessible(Stair, Ground) = TRUE
isObjectProperty(Stair.isEscape) = TRUE

       OR isObjectProperty(Stair.isSpecialEscape) = TRUE



   }

   Passage  myPassage{

       isGoThrough(myStair, Road, Passage)=True

       OR isGoThrough(myStair, OpenSpace, Passage )=True

   }



   isExist(myDoor)=True

   isExist(myPassage)=True

   getResult(EDBA_41_1_1)=True

   getResult(EDBA_41_1_2)=True

   getResult(EDBA_41_1_3)=True

}


Check(EDBA_41_1_1){

  IF (CS) THEN KS END IF 

}

CS{

getObjectProperty(Building.usage)="DetachedHouse"

}

KS{

  getObjectProperty(Passage.effectiveWidth)> 0.9M

}


Check(EDBA_41_1_2){

   IF (CS) THEN  KS END IF

}



CS{

FloorSlab.area> 500 m2 

   Building.usage="CulturalAndAssemblyFacility"

   OR Building.usage="ReligiousFacility" 

   OR  Building.usage="MedicalFacility" 

   OR Building.usage="AmusementFacility" 

   OR Building.usage="FuneralParlor"  

}



KS{

  Passage.effectiveWidth> 3m ;

}


Check(EDBA_41_1_3){

IF (CS) THEN KS END IF

}

CS{

Building.usage !="DetachedHouse"

OR   Building.usage !="CulturalAndAssemblyFacility"

   OR Building.usage !="ReligiousFacility" 

   OR  Building.usage !="MedicalFacility" 

   OR Building.usage !="AmusementFacility" 

   OR Building.usage !="FuneralParlor"  
}

KS{

 getObjectProperty(Passage.effectiveWidth)> 1.5m ;

}

//건축법 시행령 44조 (피난 규정의 적용례)



Check(EDBA_44){

   IF CS THEN KS

}



CS{

   Door myDoor{

      isObjectProperty(Door.isEntrance)=True

   }



   Object  myElement {

        getObject(Window)

        getObject(Opening)

        getObject(myDoor)

   }

   

   FloorSlab myFloorSlab{



        getObjectProperty(FloorSlab.isFireResistantStructure)=True

   }



     Wall myWall{

        getObjectProperty(FloorSlab.isFireResistantStructure)=True

        hasObject(Wall, myElement) =False

   }



   isFirePartition(Building, myFloorSlab)=True

   OR  isFirePartition(Building, myWall)=True

   



}



KS{

   getResult(EDBA_34)=True

   getResult(EDBA_35)=True

   getResult(EDBA_36)=True

   getResult(EDBA_37)=True

   getResult(EDBA_38)=True

   getResult(EDBA_39)=True

   getResult(EDBA_40)=True

   getResult(EDBA_41)=True

}

//건축법 시행령 46조 (방화구획의 설치) 1항

Check(EDBA_46_1){

   IF (!CS1 AND CS2) THEN KS

}





CS1{

  getBuildingUsage()="NuclearReactorAndRelatedFacility"

}



CS2{

  (isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

  OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE))

  AND Building.grossFloorArea>1000 m2

}



KS{



  Floor myFloor{

      isObjectProperty(FloorSlab.isFireResistantStructure)=TRUE

  }

  Wall myWall{

      isObjectProperty(Wall.isFireResistantStructure)=TRUE

  }

  Door myDoor{

      isObjectProperty(Door.isStrictFireproofDoor)=TRUE

  }



  isFirePartition(Building, myFloor)=TRUE

  AND  isFirePartition(Building, myWall)=TRUE

  AND  isFirePatrition(Building, myDoor)=TRUE



  AND getResult(REFB_14_1)=TRUE

  AND getResult(REFB_14_2)=TRUE

  AND getResult(REFB_14_3)=TRUE



}


//건축법 시행령 46조 (방화구획의 설치) 2항
check(EDBA_46_2){
IF CS THEN KS
}

KS{ 
getResult(EDBA_46_1)=FALSE
}

CS{
getResult(EDBA_46_2_2)=TRUE
OR getResult(EDBA_46_2_3)=TRUE
OR getResult(EDBA_46_2_4)=TRUE
OR getResult(EDBA_46_2_5)=TRUE
OR getResult(EDBA_46_2_6)=TRUE
OR getResult(EDBA_46_2_7)=TRUE 
}


//건축법 시행령 46조 (방화구획의 설치) 2항 2호

check(EDBA_46_2_2){

IF CS THEN KS

}



KS{

isExist(StationaryLargeComponent)=TRUE

}



CS{

Floor myFloor{
getFloorNumber()<0
}

AND isAccessible(myFloor, Ground) = TRUE

}


//건축법 시행령 46조 (방화구획의 설치) 2항 3호

check(EDBA_46_2_3){

KS

}



KS{

 isObjectProperty(Stair.Space.isFirePartition)=TRUE

 OR isObjectProperty(Passage.isFirePartition)=TRUE

 OR isObjectProperty(ElevatorShaft.isFirePartition)=TRUE

}


//건축법 시행령 46조 (방화구획의 설치) 2항 4호

check(EDBA_46_2_4){

KS

}



KS{
Floor myFloor{
getObject(TopFloor)
OR  isObjectProperty(Floor.isEscape)=TRUE
}


 AND 

 (getSpaceUsage(myFloor.Space)="ConferenceRoom"

 OR getSpaceUsage(myFloor.Space)="Hall"

 OR getSpaceUsage(myFloor.Space)="SkyLounge"

 OR getSpaceUsage(myFloor.Space)="Lobby"

 OR isObjectProperty(Zone.isEgressSafetyZone)= TRUE

}


//건축법 시행령 46조 (방화구획의 설치) 2항 5호
check(EDBA_46_2_5){
     Zone myZone{
          isObjectProperty(Zone.isOccupiedByOneHousehold) = TRUE
     }
     getBuildingUsage() = "DuplexMultiUnitHouses"
     hasSpace(myZone, Floor) = TRUE
     getFloorNumber(Floor) != 1
}


//건축법 시행령 46조 (방화구획의 설치) 2항 6호

check(EDBA_46_2_6){

KS

}



KS{

  isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

  AND isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE

  AND getSpaceUsage()=ParkingLot

}


//건축법 시행령 46조 (방화구획의 설치) 2항 7호

check(EDBA_46_2_7){

KS

}



KS{

getBuildingUsage()="DetachedHouses"

OR getBuildingUsage()="FacilitiesForAnimalsAndPlants"

OR (getBuildingUsage()="CorrectionalFacilityANDMilitaryFacilities" and (getSpaceUsage()= "Assembly" OR "Gymnasium" OR "Warehouses")

}


//건축법 시행령 46조 (방화구획의 설치) 3항
check(EDBA_46_3){
KS
}

KS{
getResult(BA_50_1)=TRUE
AND isGroupedFirePartition()=TRUE
}


//건축법 시행령 46조 (방화구획의 설치) 4항

check(EDBA_46_4){

IF CS THEN KS1 AND KS2

}



Zone myZone{

     isObjectProperty(Zone.isOccupiedByOneHousehold) = TRUE

}



KS1{
Space mySpace{
Space.isEscape = TRUE
}

isExist(Balcony)=TRUE

AND hasElement(Balcony,mySpace)=TRUE

AND (getResult(EDBA_46_4_1)=TRUE

AND getResult(EDBA_46_4_2)=TRUE

AND getResult(EDBA_46_4_3)=TRUE

AND getResult(EDBA_46_4_4)=TRUE)

}



KS2{
Stair myStair{
Stair.isDirect = TRUE
}

isGoThrough(myZone,mySpace,myZone)=TRUE

AND isGoThrough(mySpace,myZone,myStair)=TRUE

}



CS{

getBuildingUsage()="MultiUnitHouses.ApartmentHouses"

AND Floor.number >=4

AND isDirectlyAccessible(myZone, myStair)=TRUE

AND myStair.Number>=2

}


//건축법 시행령 46조 (방화구획의 설치) 4항 1호

check(EDBA_46_4_1){

KS

}



KS{
Space mySpace{
isObjectProperty(Space.isEscape) = TRUE
}
isConnectedToExternal(mySpace)=TRUE

}


//건축법 시행령 46조 (방화구획의 설치) 4항 2호

check(EDBA_46_4_2){

KS

}



KS{
Space mySpace{
isObjectProperty(Space.isEscape) = TRUE
}
isObjectProperty(mySpace.isFirePartition)=TRUE

}


//건축법 시행령 46조 (방화구획의 설치) 4항 3호
check(EDBA_46_4_3)

CS1{
}


CS2{
}


KS1{
}


KS2{
}


//건축법 시행령 46조 (방화구획의 설치) 5항

Check(EDBA_5){

CS 

}

Space mySpace{
Space.isEscape = TRUE
}

CS{getObjectProperty(Building.usage)="ApartmentHouses"
  AND isExist(Balcony)=TRUE

  AND (hasObject(Balcony,Structure)=TRUE

  AND (getResult(EDBA_5_1)=TRUE

  or getResult(EDBA_5_2)=TRUE

  or getResult(EDBA_5_3)=TRUE)

  AND isExist(mySpace)=FALSE

}


//건축법 시행령 46조 (방화구획의 설치) 5항 1호
Check(EDBA_46_5_1){CS
}

CS{
   isObjectProperty(Wall.isPartitionWall)=TRUE
   AND isObjectProperty(Wall.isLightWeightStructure)=TRUE
}


//건축법 시행령 46조 (방화구획의 설치) 5항 2호

Check(EDBA_46_5_2){CS

}





CS{
Opening myOpening{
Opening.isEscape = TRUE
}
Wall myWall{
  isObjectProperty(Wall.isPartitionWall)=TRUE
}
  AND hasObject(myWall,myOpening)=TRUE

}


//건축법 시행령 46조 (방화구획의 설치) 5항 3호
Check(EDBA_46_5_3){
CS}


CS{

AND getResult(REFB_14_3)=TRUE
}

//건축법 시행령 47조 (방화에 장애가 되는 용도의 제한) 1항

Check(EDBA_47_1){
   IF !CS THEN KS
}

CS{
   getResult(EDBA_47_1_1)=True
   OR getResult(EDBA_47_1_3)=True

   getResult(REFB_14-2)=True
}

KS{
   Space mySpace1{
      getSpaceUsage(Space)="MedicalFacility"
      OR getSpaceUsage(Space)="FacilitiesForTheAgedAndChildren.ChildrenRelatedFacility"
      OR getSpaceUsage(Space)="FacilitiesForTheAgedAndChildren.WelfareFacilityForTheAged"
      OR getSpaceUsage(Space)="MultiUnitHouse"
   }

   Space mySpace2{
      getSpaceUsage(Space)="FuneralParlor"
      OR getSpaceUsage(Space)="AmusementFacility"
      OR getSpaceUsage(Space)="FacilityForStorageAndTreatmentOfDangerousSubstance"
      OR getSpaceUsage(Space)="Factory"
      OR getSpaceUsage(Space)="FacilityForMotorVehicle.AutomobileRepairShop"

    
   isExistTogether(mySpace1, mySpace2)=False
    
   }
   
} 


// 건축법 시행령 47조 (방화에 장애가 되는 용도의 제한) 1항 1호

Check(EDBA_47_1_1){
       KS
}

KS{
     Space mySpace1{
         getSpaceUsage(Space)="MultiUnitHouse.Dormitory"
     }
 
     Space mySpace2{
         getSpaceUsage(Space)="Factory"
     }


    isExistTogether(mySpace1, mySpace2)=True
       
}


//건축법 시행령 47조 (방화에 장애가 되는 용도의 제한) 1항 3호

Check(EDBA_47_1_3){
         KS
}

KS{
    Space mySpace1{
        getSpaceUsage(Space)="MultiUnitHouse"
    }
 
    Space mySpace2{
        getSpaceUsage(Space)="AmusementFacility"
    }

  
    Building myBuilding{
       isObjectProperty(Building.isHighriseBuilding)=True
    }

   
    isExistTogether(mySpace1, mySpace2, myBuilding)=True

   //다만, 주택의 출입구ㆍ계단 및 승강기 등을 주택 외의 시설과 분리된 구조로 하여야 한다.

}


//건축법 시행령 47조 (방화에 장애가 되는 용도의 제한) 2항 



Check(EDBA_47_2){

      KS

}



  Space  myFacility{

    getResult(EDBA_47_2_1)=True

  } 



  Space  myFacility2{

    OR getResult(EDBA_47_2_2)=True

  } 

     



KS{

    isShared(myFacility.Building, myFacility2.Building)=False

}


//건축법 시행령 47조 (방화에 장애가 되는 용도의 제한) 2항 1호

Check(EDBA_47_2_1){
       KS
}

KS{
     getBuildingUsage()="FacilitiesForTheAgedAndChildren.ChildrenRelatedFacility"
     OR getBuildingUsage()="FacilitiesForTheAgedAndChildren.WelfareFacilityForTheAged" 
     OR getBuildingUsage()="CommercialFacility.WholesaleMarket"
     OR getBuildingUsage()="CommercialFacility.RetailMarket"
}


//건축법 시행령 47조 (방화에 장애가 되는 용도의 제한) 2항 2호



Check(EDBA_47_2_2){

      KS

}



KS{

       getBuildingUsage()="DetachedHouse.MultiUserHouse"

       OR getBuildingUsage()="DetachedHouse.MultiFamilyHouse"

       OR getBuildingUsage()="MultiUnitHouse"

       OR getBuildingUsage()="ClassINeighborhoodLivingFacility.MaternityCenter"

       OR getBuildingUsage()="ClassINeighborhoodLivingFacility.PostnatalCareCenter"

       OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.CommunalLivingFacility"



}

//건축법 시행령 48조 (계단ㆍ복도 및 출입구의 설치) 1항

Check(EDBA_48_1){
     IF CS THEN KS 
}

CS{
   getGrossFloorArea()>200 m2
}

KS{
   getResult(REFB_15_1)=True
   getResult(REFB_15_1_1)=True
   getResult(REFB_15_1_2)=True
   getResult(REFB_15_1_3)=True
   getResult(REFB_15_1_4)=True

   getResult(REFB_15_2)=True
   getResult(REFB_15_2_1)=True
   getResult(REFB_15_2_2)=True
   getResult(REFB_15_2_3)=True
   getResult(REFB_15_2_4)=True
   getResult(REFB_15_2_5)=True
   getResult(REFB_15_2_6)=True

   getResult(REFB_15-2_1)=True
   getResult(REFB_15-2_2)=True
   getResult(REFB_15-2_2_1)=True
   getResult(REFB_15-2_2_2)=True
   getResult(REFB_15-2_2_3)=True

   getResult(REFB_15-2_3)=True
   getResult(REFB_15-2_3_1)=True
   getResult(REFB_15-2_3_2)=True
}


//건축법 시행령 48조 (계단ㆍ복도 및 출입구의 설치)2항

Check(EDBA_48_2){
     IF CS THEN KS 
}

CS{
    getResult(EDBA_39_1_1)=True
    OR  getResult(EDBA_39_1_2)=True
    OR  getResult(EDBA_39_1_3)=True
    OR  getResult(EDBA_39_1_4)=True
    OR  getResult(EDBA_39_1_5)=True
    OR  getResult(EDBA_39_1_6)=True
    OR  getResult(EDBA_39_1_7)=True
    OR  getResult(EDBA_39_1_8)=True
    OR  getResult(EDBA_39_1_9)=True
    OR  getResult(EDBA_39_1_10)=True
}

KS{
   getResult(REFB_11_1)=True
   getResult(REFB_11_2)=True
   getResult(REFB_11_3)=True
   getResult(REFB_11_4)=True
   getResult(REFB_11_5)=True
   getResult(REFB_11_6)=True
}

// 건축법 시행령 50조 (거실반자의 설치)
check(EDBA_50){
     IF (CS) THEN KS
}

CS{
     Building.usage != "Factory"
     OR Building.usage != "Warehouse"
     OR Building.usage != "FacilityForStorageAndTreatmentOfDangerousSubstance"
     OR Building.usage != "FacilityForAnimalAndPlant"
     OR Building.usage != "ResourceRecyclingFacility"
     OR Building.usage != "CemeteryAndRelatedFacility"
}

KS{
     getResult(REFB_16_1) = TRUE
     getResult(REFB_16_2) = TRUE
}

// 건축법 시행령 51조 (거실의 채광 등) 1항
check(EDBA_51_1){
     IF CS THEN KS
}

CS{
     getBuildingUsage() = "DetachedHouse.Room"
     OR getBuildingUsage() = "MultiUnitHouse.Room"
     OR getBuildingUsage() = "School.Classroom"
     OR getBuildingUsage() = "MedicalFacility.Ward"
     OR getBuildingUsage() = "LodgingFacility.GuestRoom"
}

KS{
     hasElement(Window) = TRUE
}


//건축법 시행령 51조 (거실의 채광 등) 2항
Check(EDBA_51_2){
     IF (!CS1 AND CS2) THEN KS
}


CS1{
     Floor myFloor{
          isObjectProperty(Floor.isEscape) = TRUE
     }
     getFloorNumber(Room) = getFloorNumber(myFloor)
}

CS2{
     getBuildingStoriesCount() >= 6
     getResult(EDBA_51_2_1) = True
     OR getResult(EDBA_51_2_2) = True
     OR getResult(EDBA_51_2_3) = True
     OR getResult(EDBA_51_2_4) = True
     OR getResult(EDBA_51_2_5) = True
     OR getResult(EDBA_51_2_6) = True
     OR getResult(EDBA_51_2_7) = True
     OR getResult(EDBA_51_2_8) = True
     OR getResult(EDBA_51_2_9) = True
     OR getResult(EDBA_51_2_10) = True
     OR getResult(EDBA_51_2_11) = True
     OR getResult(EDBA_51_2_12) = True
     OR getResult(EDBA_51_2_13) = True
     OR getResult(EDBA_51_2_14) = True
     OR getResult(EDBA_51_2_15) = True
}

KS{
     hasSpace(Room, SmokeExhaustionSystem) = True
     getResult(RFB_14_1) = True
     getResult(REFB_17_1) = True
     getResult(REFB_17_2) = True
}



//건축법 시행령 51조 (거실의 채광 등) 2항 1호
Check(EDBA_51_2_1){
     KS1 OR KS2
}     
KS1{
     Space mySpace{
          getBuildingUsage() = "ClassIINeighborhoodLivingFacility.PerformanceHall"
          OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"
          OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.FacilityForProvidingInternetComputerGameService"     
     }

     getFloorArea(mySpace) >= 300 m2
}

KS2{
     getBuildingUsage() = "ClassIINeighborhoodLivingFacility.CommunalLivingFacilities"
}



//건축법 시행령 51조 (거실의 채광 등) 2항 2호
Check(EDBA_51_2_2){
     getBuildingUsage() = "CulturalAndAssemblyFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 3호
Check(EDBA_51_2_3){
     getBuildingUsage() = "ReligiousFacility"
}


Check(EDBA_51_2_4){

  getBuildingUsage()="CommercialFacility"

}


//건축법 시행령 51조 (거실의 채광 등) 2항 5호
Check(EDBA_51_2_5){
     getBuildingUsage() = "TransportationFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 6호
Check(EDBA_51_2_6){
     getBuildingUsage() = "MedicalFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 7호
Check(EDBA_51_2_7){
     getBuildingUsage() = "EducationAndResearchFacility.Laboratory"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 8호
Check(EDBA_51_2_8){
     getBuildingUsage() = "FacilitiesForTheAgedAndChildren.ChildrenRelatedFacilities"
     OR getBuildingUsage() = "FacilitiesForTheAgedAndChildren.WelfareFacilitiesForTheAged"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 9호
Check(EDBA_51_2_9){
     getBuildingUsage() = "Trainingfacility.YouthHostels"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 10호
Check(EDBA_51_2_10){
     getBuildingUsage() = "SportsFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 11호
Check(EDBA_51_2_11){
     getBuildingUsage() = "BusinessFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 12호
Check(EDBA_51_2_12){
     getBuildingUsage() = "LodgingFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 13호
Check(EDBA_51_2_13){
     getBuildingUsage() = "AmusementFacility"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 14호
Check(EDBA_51_2_14){
     getBuildingUsage() = "FacilityForTourismAndRelaxation"
}


//건축법 시행령 51조 (거실의 채광 등) 2항 15호
Check(EDBA_51_2_15){
     getBuildingUsage() = "FuneralParlors"
}



// 건축법 시행령 51조 (거실의 채광 등) 3항

check(EDBA_51_3){

     IF CS THEN KS

}



CS{

Window myWindow{
getObjectProperty(Window.panelOperationType) = "SwingingWindow"
}
     getBuildingUsage() = "Officetels.Room"

     getElementHeight(myWindow) <= 1.2 m

}



KS{

     isExist(FallPreventionSafetyFacility) = TRUE

     getResult(REFB_17_4) = TRUE

}

//건축법 시행령 52조 (거실 등의 방습)
Check(EDBA_52){
IF CS THEN KS}

CS{
  getResult(EDBA_52_0_1)=TRUE
  OR getResult(EDBA_52_0_2)=TRUE
  OR getResult(EDBA_52_0_3)=TRUE
  getObject(Floor)
}

KS{
  getResult(REFB_18_1)=TRUE
  AND getResult(REFB_18_2)=TRUE
}


//건축법 시행령 52조 (거실 등의 방습) 1호

Check(EDBA_52_0_1){

CS}



CS{

hasObject(BottomFloor, Room) = TRUE
 getObjectProperty(FloorSlab.Structure.materialType) = "Timber"

}


//건축법 시행령 52조 (거실 등의 방습) 2호

Check(EDBA_52_0_2){

KS

}



KS{

Building myBuilding1{
Building.usage = "ClassiNeighborhoodLivingFacilites.BathHouse"
}
Building myBuilding2{
Building.usage = "ClassiNeighborhoodLivingFacilites" OR "RestingRestaurant"
}

getSpaceUsage(myBuilding1.Space)="BathRoom"

getSpaceUsage(myBuilding2.Space)="Kitchen"

}


//건축법 시행령 52조 (거실 등의 방습) 3호

Check(EDBA_52_0_3){

KS

}



KS{

Building myBuilding1{
Building.usage = "ClassiiNeighborhoodLivingFacilites.Restaurant" OR "ClassiiNeighborhoodLivingFacilites.RestingRestaurant" OR "ClassiiNeighborhoodLivingFacilites.Bakery"
}
Building myBuilding2{
Building.usage = "ClassiiNeighborhoodLivingFacilites.LodgingFacility" 
}

getSpaceUsage(myBuilding1.Space)="Kitchen"

getSpaceUsage(myBuilding2.Space)="BathRoom"


}

// 건축법 시행령 53조 (경계벽 등의 설치) 1항



check(EDBA_53_1){

     IF CS THEN KS

}



CS{

     getResult(EDBA_53_1_1) = TRUE

     OR getResult(EDBA_53_1_2) = TRUE

     OR getResult(EDBA_53_1_3) = TRUE

     OR getResult(EDBA_53_1_4) = TRUE

}



KS{

     getResult(REFB_19_1)=True     

        getResult(REFB_19_2)=True

}


// 건축법 시행령 53조 (경계벽 등의 설치) 1항 1호



check(EDBA_53_1_1){

     KS

}




KS{



Zone myZone1{

Zone.Building.usage = “DetachedHouse.MultiFamilyHouse ”

}



Zone myZone2{

Zone.Building.usage = “MultiUnitHouse”

}



Balcony myBalcony{

Balcony.usage != “BedRoom”

Balcony.usage != “LivingRoom”

}



Wall myWall1{

isObjectProperty(Wall.isPartitionWall)=TRUE

hasObject(myZone1.Household, Wall) =TRUE

hasObject(myBalcony,Wall) =FALSE

}



Wall myWall1{

isObjectProperty(Wall.isPartitionWall)=TRUE

hasObject(myZone2.Household, Wall) =TRUE

hasObject(myBalcony,Wall) =FALSE

}





isExist(myWall1)=TRUE

isExist(myWall2)=TRUE



}


// 건축법 시행령 53조 (경계벽 등의 설치) 1항 2호



check(EDBA_53_1_1){

     KS

}

KS{


Space mySpace1{

Space.Building.usage = “MultiUnitHouse.Dormitory”

Space.name = “BedRoom”

}



Space mySpace1_1{

Space.Building.usage = “MultiUnitHouse.Dormitory”

Space.name != “BedRoom”

}



Space mySpace2{

Space.Building.usage = “MedicalFacility”

Space.name = “Ward”

}



Space mySpace2_1{

Space.Building.usage = “MedicalFacility”

Space.name != “Ward”

}



Space mySpace3{

Space.Building.usage = “EducationAndResearchFacility.School”

Space.name = “ClassRoom”

}

Space mySpace3_1{

Space.Building.usage = “EducationAndResearchFacility.School”

Space.name != “ClassRoom”

}



Space mySpace4{

Space.Building.usage = “LodgingFacility”

Space.name = “GuestRoom”

}

Space mySpace4_1

Space.Building.usage = “LodgingFacility”

Space.name != “GuestRoom”

}



Wall myWall1{

isObjectProperty(Wall.isPartitionWall)=TRUE

hasObject(mySpace1, Wall) =TRUE

}



Wall myWall2{

isObjectProperty(Wall.isPartitionWall)=TRUE

hasObject(mySpace2, Wall) =TRUE

}



Wall myWall3{

isObjectProperty(Wall.isPartitionWall)=TRUE

hasObject(mySpace3, Wall) =TRUE

}



Wall myWall4{

isObjectProperty(Wall.isPartitionWall)=TRUE

hasObject(mySpace4, Wall) =TRUE

}



(hasObject(mySpace1, myWall) =TRUE

hasObject(mySpace1_1, myWall) =FALSE)

OR

(hasObject(mySpace2, myWall) =TRUE

hasObject(mySpace2_1, myWall) =FALSE)

OR

(hasObject(mySpace3, myWall) =TRUE

hasObject(mySpace3_1, myWall) =FALSE)

OR

(hasObject(mySpace4, myWall) =TRUE

hasObject(mySpace4_1, myWall) =FALSE)



}


// 건축법 시행령 53조 (경계벽 등의 설치) 1항 3호



check(EDBA_53_1_3){

     KS

}


KS{

Space mySpace1{

Space.Building.usage = “ClassIINeighborhoodLivingFacility.CommunalLivingFacility”

}



Wall myWall{

isObjectProperty(Wall.isPartitionWall)=TRUE
hasObject(mySpace1, Wall) =TRUE
}



isObjectProperty(myWall.isSharedByHouseholds) = TRUE


}


// 건축법 시행령 53조 (경계벽 등의 설치) 1항 4호





check(EDBA_53_1_4){

     KS

}


KS{

Building  myBuilding{

Zone.Building.usage = “FacilitiesForTheAgedAndChildren.WelfareFacilityForTheAged ”

getResult(WOPA_32_1_3)=TRUE

}



Wall myWall{

isObjectProperty(Wall.isPartitionWall)=TRUE
hasObject(myBuilding, Wall) =TRUE
}



isObjectProperty(myWall.isSharedByHouseholds) = TRUE



}


//건축법 시행령 53조 (경계벽 등의 설치) 2항 

Check(EDBA_53_2){
    IF CS THEN KS
}

CS{
   getResult(EDBA_53_2_1)=True
   OR getResult(EDBA_53_2_2)=True
   OR getResult(EDBA_53_2_3)=True
   OR getResult(EDBA_53_2_4)=True
   OR getResult(EDBA_53_2_5)=True
 }

KS{
    getResult(REFB_19_3)=True
}


//건축법 시행령 53조 (경계벽 등의 설치) 2항 1호

Check(EDBA_53_2_1){
   KS
}

KS{
   getBuildingUsage()="DetachedHouse.MultiFamilyHouse"
} 


//건축법 시행령 53조 (경계벽 등의 설치) 2항 2호

Check(EDBA_53_2_2){
   KS
}

KS{
   getBuildingUsage()="MultiUnitHouse"
   getResult(Unimplemented_HA_16)=False
} 


//건축법 시행령 53조 (경계벽 등의 설치) 2항 3호

Check(EDBA_53_2_3){
   KS
}

KS{
   getBuildingUsage()="BusinessFacility.Officetel"
   
} 


//건축법 시행령 53조 (경계벽 등의 설치) 2항 4호

Check(EDBA_53_2_4){
   KS
}

KS{
   getBuildingUsage()="ClassIINeighborhoodLivingFacility.CommunalLivingFacility"
   
} 


//건축법 시행령 53조 (경계벽 등의 설치) 2항 5호

Check(EDBA_53_2_5){
   KS
}

KS{
   getBuildingUsage()="LodgingFacility.CommunalLivingFacility"
   
}