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

Check(RFB_9_0_2){

   KS

}



KS{

    getBuildingHeight()>31 m

    getTotalFloorArea()<=500 m2

} 

def Check():
    bld = SELECT("building")
    bldHeight = bld.SELECT("height").UNIT("m").NUMBER()
    totalFloorArea = getTotalFloorArea()
    if bldHeight > 31 and totalFloorArea <=500:
        bld.SUCCESS("pass")
    else:
        bld.ERROR("error")
 

def getTotalFloorArea():
    totalArea = 0
    floors = SELECT("storey")
    for floor in floors:
        floorArea = floor.SELECT("area").UNIT('m2').NUMBER()
        totalArea += floorArea
    return totalArea 

//	비상콘센트설비의 화재안전기준(nfsc 504) 4조 (전원 및 콘센트 등) 1항 2호

Check(NFSC504_4_1_2){

	IF CS THEN KS

}



	Floor myFloor{

		getFloorNumber < 0

		hasSpace(Floor, SpecificFireFightingBuilding) = TRUE

	}



	Floor myFloor2{

		getFloorNumber >= 0

		hasSpace(Floor, SpecificFireFightingBuilding) = TRUE

	}



CS{

	(getBuildingStoriesCount() >= 7

	getGrossFloorArea(myFloor2) >= 2000m2)

	OR getTotalFloorArea(myFloor) >= 3000m2

}



KS{

	isInstalled(EmergencyPower, EmergencyPowerOutletSystem) = TRUE

	getObjectProperty(EmergencyPowerReceivingSystem.type) = "InhousePowerGenerationSystem"

	OR getObjectProperty(EmergencyPowerReceivingSystem.type) = "EmergencyPowerReceivingSystem"

} 

Python Code 변환 예정

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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

} 

area_sum_lable = '바닥면적 합계'
up_area_sum_lable = '윗층 바닥면적 합계'
clear_w_lable = '계단, 계단참의 유효면적'


def Check():
    area_sum =0
    up_area_sum = 0
    min_clear_w = 1.2
    under_stories = []

    for building in SELECT('building'):

        for storey in building.SELECT('storey'):
            if storey.SELECT('prop', '기준 지상층').BOOL():
                base_storey_exist = True
                break
            under_stories.append(storey)


        for storey in under_stories:
            if up_area_sum >= 200:
                continue

            else:
                for space in storey.SELECT('space'):
                    area_sum += space.SELECT('area').UNIT('m2').NUMBER()
                    if area_sum >= 100:
                        continue
                    else:
                        break
                    up_area_sum = area_sum

            for stair in storey.SELECT('stair'):

                clear_width = stair.SELECT('clear width').UNIT('m')
                clear_w = clear_width.NUMBER()

                if clear_w < min_clear_w:
                    clear_width.ERROR('유효너비: ' + str(clear_w) + ' < ' + str(min_clear_w))
                else:
                    clear_width.SUCCESS('유효너비: ' + str(clear_w) + ' >= ' + str(min_clear_w)) 

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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 
     
}
 

corridor_code = '33105'
std_floor_area = 200

corridor_code_label = '복도 공간분류코드'
std_floor_area_label = '기준 연면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('prop', '연면적').NUMBER() <= std_floor_area:
            continue

        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()
        if not ((bldg_use == '문화 및 집회시설' and sub_use in ['공연장' ,'집회장', '관람장', '전시장'])
            or (bldg_use == '종교시설' and sub_use == '종교집회장')
            or (bldg_use == '노유자시설' and sub_use in ['아동관련시설' ,'노인복지시설'])
            or (bldg_use == '수련시설' and sub_use == '생활권수련시설')
            or (bldg_use == '위락시설' and sub_use == '유흥주점')
            or (bldg_use == '장례시설' and sub_use == '장례식장')):
            continue

        for storey in building.SELECT('storey'):
            area = 0.0
            corridors = []
            for space in storey.SELECT('space'):
                if space.SELECT('class code').STRING() == corridor_code:
                    corridors.append(space)
                
                area += space.SELECT('area').UNIT('m2').NUMBER()
            
            min_cor_w = 1.8
            if area < 500:
                min_cor_w = 1.5
            elif area >= 1000:
                min_cor_w = 2.4

            for space in corridors:    
                width = space.SELECT('min clear width').UNIT('m')
                w = width.NUMBER()

                if w < min_cor_w:
                    width.ERROR('유효너비: ' + str(w) + ' < ' + str(min_cor_w))
                else:
                    width.SUCCESS('유효너비: ' + str(w) + ' >= ' + str(min_cor_w)) 

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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 
}


 

corridor_code = '33105'
std_floor_area = 200

corridor_code_label = '복도 공간분류코드'
std_floor_area_label = '기준 연면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('prop', '연면적').NUMBER() <= std_floor_area:
            continue

        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()
        if not ((bldg_use == '문화 및 집회시설' and sub_use in ['공연장' ,'집회장', '관람장', '전시장'])
            or (bldg_use == '종교시설' and sub_use == '종교집회장')
            or (bldg_use == '노유자시설' and sub_use in ['아동관련시설' ,'노인복지시설'])
            or (bldg_use == '수련시설' and sub_use == '생활권수련시설')
            or (bldg_use == '위락시설' and sub_use == '유흥주점')
            or (bldg_use == '장례시설' and sub_use == '장례식장')):
            continue

        for storey in building.SELECT('storey'):
            area = 0.0
            corridors = []
            for space in storey.SELECT('space'):
                if space.SELECT('class code').STRING() == corridor_code:
                    corridors.append(space)
                
                area += space.SELECT('area').UNIT('m2').NUMBER()
            
            min_cor_w = 1.8
            if area < 500:
                min_cor_w = 1.5
            elif area >= 1000:
                min_cor_w = 2.4

            for space in corridors:    
                width = space.SELECT('min clear width').UNIT('m')
                w = width.NUMBER()

                if w < min_cor_w:
                    width.ERROR('유효너비: ' + str(w) + ' < ' + str(min_cor_w))
                else:
                    width.SUCCESS('유효너비: ' + str(w) + ' >= ' + str(min_cor_w)) 

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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
}


 

corridor_code = '33105'
std_floor_area = 200

corridor_code_label = '복도 공간분류코드'
std_floor_area_label = '기준 연면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('prop', '연면적').NUMBER() <= std_floor_area:
            continue

        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()
        if not ((bldg_use == '문화 및 집회시설' and sub_use in ['공연장' ,'집회장', '관람장', '전시장'])
            or (bldg_use == '종교시설' and sub_use == '종교집회장')
            or (bldg_use == '노유자시설' and sub_use in ['아동관련시설' ,'노인복지시설'])
            or (bldg_use == '수련시설' and sub_use == '생활권수련시설')
            or (bldg_use == '위락시설' and sub_use == '유흥주점')
            or (bldg_use == '장례시설' and sub_use == '장례식장')):
            continue

        for storey in building.SELECT('storey'):
            area = 0.0
            corridors = []
            for space in storey.SELECT('space'):
                if space.SELECT('class code').STRING() == corridor_code:
                    corridors.append(space)
                
                area += space.SELECT('area').UNIT('m2').NUMBER()
            
            min_cor_w = 1.8
            if area < 500:
                min_cor_w = 1.5
            elif area >= 1000:
                min_cor_w = 2.4

            for space in corridors:    
                width = space.SELECT('min clear width').UNIT('m')
                w = width.NUMBER()

                if w < min_cor_w:
                    width.ERROR('유효너비: ' + str(w) + ' < ' + str(min_cor_w))
                else:
                    width.SUCCESS('유효너비: ' + str(w) + ' >= ' + str(min_cor_w)) 

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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
} 

Python Code 변환 예정

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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

} 

Python Code 변환 예정

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

Python Code 변환 예정

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

check(REFB_25_1_4){

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

	getObjectCount(Hydrant) >= 1

} 

Python Code 변환 예정

//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 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  
} 

Python Code 변환 예정

//건축법 시행령 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

     
} 

Python Code 변환 예정

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

Check(EDBA_36_0_2){
            KS
}

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

      getTotalFloorArea(myFloor.Room)>=1000 m2


} 

Python Code 변환 예정

//건축법 시행령 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
}

 

identified_space_codes =['33703', '33708']
min_area = 300
min_door_width = 1.5
min_door_count = 2
identified_space_codes_label ='해당 공간 명칭'
min_area_label = '바닥면적이 다음 미만일 경우 제외(m2)'
min_door_width_label = '출구 유효너비'
min_door_count_label = '유효너비 이상 최소 출구 개수'

def Check():
    for space in SELECT('space'):
        name = space.SELECT('name').STRING()
        code = space.SELECT('class code').STRING()

        if not code in identified_space_codes:
            continue
                
        area = space.SELECT('area').UNIT('m2').NUMBER()
        if area >= min_area:
            exitCnt = 0
            door_width_sum = 0
            inward_exist = False

            for door in space.SELECT('space door'):
                if door.SELECT('is inward', space).BOOL() == False:
                    door_width = door.SELECT('width').UNIT('m2').NUMBER()
                    if door_width >= min_door_width:
                        exitCnt += 1
                        door_width_sum += door_width
                else:
                    door.ERROR('안여닫이 출구')
                    inward_exist = True
                    
            if inward_exist == True:
                continue

            if exitCnt >= min_door_count:
                if door_width_sum >= (area / 100) * 0.6:
                    space.SUCCESS(name)
                else:
                    space.ERROR(name + ', 출구유효너비 합: ' + str(door_width_sum) + 'm, 바닥면적: ' + str(area) + 'm2')
            else:
                space.ERROR(name + ', 출구 수 : ' + str(exitCnt) + '( < ' + str(min_door_count) + ')')
        else:
            space.SUCCESS('바닥면적:' + str(area) + '㎡ ( < ' + str(min_area) + '㎡)') 

Check(EDBA_61_1_5){
KS}

Floor myFloor {
Floor.number>=5
}

KS{
getTotalfloorArea(myFloor)>=500 m2
} 

Python Code 변환 예정

Check(EDBA_61_1_2){

IF CS THEN KS1 OR KS2}



Building myBuilding{

getBuildingUsage()="DetachedHouse.Multi-userHouses"

OR getBuildingUsage()="DetachedHouse.Multi-familyHouses" 

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.EducationalInstitute"

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.ReadingRooms

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.CommunalLivingFacility 

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.LodgingFacility"

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.MedicalFacility"

OR getBuildingUsage()="EducationAndResearchFacility.EducationalInstitute"

OR getBuildingUsage()="BusinessFacility.Oofficetels"

OR getBuildingUsage()="FuneralParlors"

}



MBU = getObjectUsage(myBuilding)



CS{

getBuildingUsage() = MBU



Floor myfloor{

Floor.number>=3

}



KS1{

(Floor.number>=3

AND getTotalfloorarea(Room)>=200m2)





KS2{isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE

AND Floor.number>=3

getTotalfloorarea(Room)>=200m2

} 

Python Code 변환 예정

//건축법 시행령 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



} 

Python Code 변환 예정

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

Python Code 변환 예정

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

Check(EDBA_35_1_1){
	KS
}



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

	getTotalFloorArea(myFloor) <= 200m2 

} 

min_floor_area = 200
min_floor_area_label = "Minimum total floor area"

def Check():
    num = 0
    for storey in SELECT('storey'):
        if num >= 5:
            area_sum = 0
            for space in storey.SELECT('space'):      
                area_sum += space.SELECT('area').UNIT('m2').NUMBER() 
            if area_sum >= min_floor_area:
                storey.SUCCESS("Total floor area:"+ str(area_sum)  + 'm2')
            else:
                storey.FAIL("Total floor area:"+ str(area_sum) + 'm2')
        num += 1 

//건축법 시행령 56조 (건축물의 내화구조와 방화벽) 1항 3호
check(EDBA_56_1_3){
	IF !(CS) THEN KS
}

CS{
	getResult(REFB_20-2) = TRUE
}

KS{
	Floor myFloor{
		getObjectUsage(Floor) = "Factory"
	}

	getTotalFloorArea(myFloor.Space) >= 2000 m2
} 

Python Code 변환 예정

//건축법 시행령 56조 (건축물의 내화구조) 1항

check(EDBA_56_1){

        IF !CS THEN KS

}

Space mySpace{
Space.usage="StagePart"
}

Floor myFloor{

     hasSpace(mySpace, Floor) = TRUE

}



CS {

       getTotalFloorArea()<= 50m2

       AND getBuildingStoriesCount()=1

       AND getBuildingUsage()="AccessoryBuidling"

       AND isFireProofStructure("OuterWall" | "eaves" | myFloor)=TRUE

}



KS {

	getResult(EDBA_56_1_1 = TRUE  

	OR getResult(EDBA_56_1_2) = TRUE  

	OR getResult(EDBA_56_1_3) = TRUE  

	OR getResult(EDBA_56_1_4) = TRUE  

	OR getResult(EDBA_56_1_5) = TRUE  

   		

	AND isFireProofStructure(MainStructuralPart) = TRUE

} 

Python Code 변환 예정

//건축법 시행령 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

        

} 

Python Code 변환 예정

//건축법 시행령 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	

} 

Python Code 변환 예정

//건축법 시행령 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
}
 

Python Code 변환 예정

//건축법 시행령 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
}
 

Python Code 변환 예정

// 장애인ㆍ노인ㆍ임산부 등의 편의증진보장에 관한 법률 시행령 별표1 편의시설 설치 대상시설(제3조 관련)


Check(EDCDAPA_*_1_2_가_1){
getBuildingUsage()=“RetailStore”
Floor myFloor{
	getFloorUsage(Floor)=”RetailStore”
}
getTotalFloorArea(myFloor)>=300 m2
getTotalFloorArea(myFloor)<1000 m2
}


Check(EDCDAPA_*_1_2_가_2){
Building myBuilding {
getBuildingUsage()=“Barbershop”
OR getBuildingUsage()=“BeautyShop”
OR getBuildingUsage()=“Bathhouse”
}
Floor myFloor{
	getFloorUsage(Floor)= myBuilding.usage
}
getTotalFloorArea(myFloor)>=500 m2
}

Check(EDCDAPA_*_1_2_가_3){
Building myBuilding{
getBuildingUsage()=“CommunityCenter”
OR getBuildingUsage()=“PoliceBox”
OR getBuildingUsage()=“PoliceSubstation”
OR getBuildingUsage()=“PostOffice”
OR getBuildingUsage()=“HealthCenter”
OR getBuildingUsage()=“PublicLibrary”
OR getBuildingUsage()=“NationalHealthInsuranceService_NationalPensionService_Korea EmploymentAgencyForTheDisabled_KoreaWorkersCompensationAndWelfareServiceOffice”
}
Floor myFloor{
	getFloorUsage(Floor)= myBuilding.usage
}
getTotalFloorArea(myFloor)<1000 m2
}


Check(EDCDAPA_*_1_2_가_4){
getBuildingUsage()=“Shelter”
}

Check(EDCDAPA_*_1_2_가_5){
getBuildingUsage()=“PublicToilet”
}

Check(EDCDAPA_*_1_2_가_6){
Building myBuilding{
getBuildingUsage()=“Clinic_ DentalClinic_OrientalMedicalClinic_MaternityClinic”
}
Floor myFloor{
	getFloorUsage(Floor)= myBuilding.usage
}
getTotalFloorArea(myFloor)>=500 m2
}

Check(EDCDAPA_*_1_2_가_7){
getBuildingUsage()=“CommunityChildCenter”
Floor myFloor{
	getFloorUsage(Floor)= “CommunityChildCenter”
}
getTotalFloorArea(myFloor)>=300 m2
}


Check(EDCDAPA_*_1_2_나_1){
getBuildingUsage()=“Restaurant”
Floor myFloor{
	getFloorUsage(Floor)= “CommunityChildCenter”
}
getTotalFloorArea(myFloor)>=300 m2
}

Check(EDCDAPA_*_1_2_나_2){
Building myBuilding {
(getBuildingUsage()=“RestingRestaurant”
OR getBuildingUsage()=“Bakery”)
getBuildingUsage() !=”ClassINeighborhoodLivingFacility”
}
Floor myFloor{
	getFloorUsage(Floor)= myBuilding.usage
}
getTotalFloorArea(myFloor)>=300 m2

}

Check(EDCDAPA_*_1_2_나_2){
getBuildingUsage()=“MassageParlor”
Floor myFloor{
	getFloorUsage(Floor)= “MassageParlor”
}
getTotalFloorArea(myFloor)>=500 m2

}

Check(EDCDAPA_*_1_2_카_1){
getBuildingUsage()=“PublicOfficeBuilding. OfficeBuildingOfLocalGovernment ”
getBuildingUsage() !=”ClassINeighborhoodLivingFacility”
}

Check(EDCDAPA_*_1_2_카_2){
Building myBuilding{
getBuildingUsage()=“GeneralBusinessFacility.FinanceBusiness”
OR getBuildingUsage()=“GeneralBusinessFacility.Office”
OR getBuildingUsage()=“GeneralBusinessFacility.NewspaperOffice”
OR getBuildingUsage()=“GeneralBusinessFacility. Officetel”
}
Floor myFloor {
 getFloorUsage()=myBuilding.usage
}
getTotalFloorArea(myFloor)>=500 m2
}

Check(EDCDAPA_*_1_2_카_3){
Building myBuilding{
getBuildingUsage()=“GeneralBusinessFacility.NationalHealthInsuranceService_NationalPensionService_Korea EmploymentAgencyForTheDisabled_KoreaWorkersCompensationAndWelfareServiceOffice”
}
Floor myFloor {
 getFloorUsage()=myBuilding.usage
}
getTotalFloorArea(myFloor)>=1000 m2
}
 

Python Code 변환 예정

//주차장법 시행규칙 6조 (노외주차장의 구조·설비기준) 5항

Check(ERPA_6_5){

	IF CS THEN KS

}



CS{

	ParkingLot myParkingLot{

		isObjectProperty(ParkingLot.isOffStreetParking) = TRUE

		getResult(PLA_20_2) = TRUE

		OR getResult(PLA_20_3) = TRUE

	}



	hasSpace(myParkingLot,SubsidiaryFacility) = TRUE

	getTotalFloorArea(myParkingLot.facilityArea)

}



KS{

	getFloorArea(ParkingLotSubsidiaryFacility) <= getTotalObjectArea(ParkingLot)*0.4

} 

Python Code 변환 예정

//주차장법 시행령 별표1 부설주차장의 설치대상 시설물 종류 및 설치기준





Check(EDPA_*_1_1){

IF CS THEN KS

}

Space mySpace1{

getBuildingUsage()=” AmusementFacility”

myTotalFloorArea = getTotalFloorArea(mySpace1)

CS{

isExist(mySpace1)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea/100

}





Check(EDPA_*_1_2){

IF CS THEN KS

}

Space mySpace2{

(getBuildingUsage()= “CulturalAndAssemblyFacility”

AND getBuildingUsage() !=” Auditorium”)

OR (getBuildingUsage() = “ReligiousFacility | CommercialFacility | TransportationFacilit”

OR getBuildingUsage() = ”MedicalFacility”

AND getBuildingUsage() != “MentalHospital | ConvalescentHospital | DetentionHoispital”)

OR (getBuildingUsage() = “SportsFacility” 

AND getBuildingUsage() != “GolfCourse | GolfDrivingRange | OurdoorSwimmingPool”)

OR (getBuildingUsage()= “BusinessFacility”

AND getBuildingUsage() != “ForeignOfficialResidence | Officetels” )

}

myTotalFloorArea2 = getTotalFloorArea(mySpace2)

}

CS{

isExist(mySpace2)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea2/150

}



Check(EDPA_*_1_3){

IF CS THEN KS

}

Space mySpace3{

 ((getBuildingUsage ()=” ClassINeighborhoodLivingFacility”

AND getSpaceUsage != “PublicToilet | Shelter | CommunityChildCenter”)

OR getBuildingUsage ()=”ClassIINeighborhoodLivingFacility”

OR getBuildingUsage ()=”LodgingFacility”)

}

myTotalFloorArea3 = getTotalFloorArea(mySpace3)

}

CS{

isExist(mySpace3)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea3/200

}





Check(EDPA_*_1_4){

IF CS1 THEN KS1 OR CS2 THEN KS2

}

Space mySpace1{

getBuildingUsage ()=” DetachedHouse”

}

myTotalFloorArea = getTotalFloorArea(mySpace1)

}

CS1{

myTotalFloorArea>50 

AND myTotalFloorArea<=150

}

KS1{

isObjectProperty(parkingLot.numberofParkingUnit)=1

}

CS2{

myTotalFloorArea>150 

}

KS2{

(myTotalFloorArea-150)/100+1=ParkingLot.numberofParkingUnit

}





Check(EDPA_*_1_7){

IF CS THEN KS

}

Space mySpace7{

getBuildingUsage ()=”Trainingfacility” 

getBuildingUsage ()=”Factory”

getBuildingUsage () != ”AptartmentTypeFactory”

}

myTotalFloorArea7 = getTotalFloorArea(myspace7)

CS{

isExist(mySpace7)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea7/400

}



Check(EDPA_*_1_8){

IF CS THEN KS

}

Space mySpace8{

getBuildingUsage ()= “Warehouse”

}

myTotalFloorArea8 = getTotalFloorArea(mySpace8)

}

CS{

isExist(mySpace8)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea8/400

}



Check(EDPA_*_1_9){

IF CS THEN KS

}

Space mySpace9{

getBuildingUsage ()= “DormitoryForStudents”

}

myTotalFloorArea9 = getTotalFloorArea(myspace9)

CS{

isExist(mySpace9)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea9/400

}





Check(EDPA_*_1_10){

IF CS THEN KS

}

Space mySpace10 { 

getObject(Space) != myspace1 | myspace2 | myspace3 | myspace4 | myspace5 | myspace6 | myspace7 | myspace8 | myspace9 |

}

myTotalFloorArea10 = getTotalFloorArea(mySpace10)

}

CS{

isExist(mySpace9)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea10/300

}





Check(EDPA_*_1_0_1){

IF CS THEN KS

}

CS{

getResult(EDPA_*_1_0_1_가)= TRUE

OR getResult(EDPA_*_1_0_1_나)= TRUE

OR getResult(EDPA_*_1_0_1_다)= TRUE

OR getResult(EDPA_*_1_0_1_라)= TRUE

OR getResult(EDPA_*_1_0_1_마)= TRUE

OR getResult(EDPA_*_1_0_1_바)= TRUE

OR getResult(EDPA_*_1_0_1_사)= TRUE

}

KS{

isExist(ParkingLot.isAttachedParking)=FALSE

}



Check(EDPA_*_1_0_1_가){

KS

}

isExist(ClassINeighborhoodLivingFacility.Substation)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.PumpingStation)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.PurificationPlant)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.Shelter)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.PublicToilet)=TRUE

Check(EDPA_*_1_0_1_나){

KS

}

isExist(ReligiousFacility.Monastery)=TRUE

OR isExist(ReligiousFacility.Convent)=TRUE

OR isExist(ReligiousFacility.Chapel)=TRUE

OR isExist(ReligiousFacility.Shrine)=TRUE

Check(EDPA_*_1_0_1_다){

KS

}

isExist(getBuildingUsage()=”FacilityForAnimalAndPlant”)=TRUE

AND isExist(getBuildingUsage()=”SlaughterHouse”)=FALSE

AND isExist(getBuildingUsage()=”ChickenSlaughterHouse”)=FALSE

Check(EDPA_*_1_0_1_라){

KS

}

isExist(FacilityForBroadcastingAndTelecommunication.TransmitAndReceptionAndTransitFacility)=TRUE

Check(EDPA_*_1_0_1_마){

KS

}

getObjectProperty(Building.isExclusiveUseOfParkingLot) = FALSE

(getBuildingUsage() != "CommercialFacility.DepartmentStore" OR "CommercialFacility.ShoppingCenter" OR  "LargeStore"

OR getBuildingUsage() != "CulturalAndAssemblyFacility.MovieTheater" OR  "CulturalAndAssemblyFacility.ExhibitionHall" OR "CulturalAndAssemblyFacility.WeddingHall"

Check(EDPA_*_1_0_1_바){

KS

}

getBuildingUsage()= “Station”

Check(EDPA_*_1_0_1_사){

KS

}

getResult(EDBA_6_1_4)=TRUE









Check(EDPA_*_1_0_4){

KS

}

Space mySpace{

getBuildingUsage()= “DetachedHouse”

getBuildingUsage() !=”Multi-familyHouses”

}

getTotalArea(mySpace)<=50m2

getTotalArea(mySpace)/100 = ParkingLot.numberOfParkingUnit 

Python Code 변환 예정