Results form the interface workshop.

[pfmephisto]

Over the last developer meetings we have tried to sketch out how the library is broken up in to different modules and an also made a first attempt at defining the interfaces between the modules. Here we want to share the progress and open up for comments and contributions.

Otherwise the next steps would be to set up the library, write test cases, implement the functions and see where we haven't thought things through well enough.

The main modules are:

• Geometry
• Filter
• Connector
• Mapping
• Calculation
• Results

Bellow there is a list of interfaces and methods that we associate with each module.

Geometry

interface Project {
    name: string
    description: string
    id: string
    geometry: GeometryObject[]
    sqm?: number
    projectType?: string
    source?: string
    location?: string
}

interface GeometryObject {
    id: string // uuid 
    Name: string
    URI?: string // Link to geometry
    Value: Dict[Unit, RetriveValue]
    ... // Can have additiona fields
};

type RetriveValue = (unit: Unit) => number;

enum Unit {
    m,
    m2,
    m3,
    kg,
    piece,
}

Filter

// Name : List of Arguments
interface FilterList {
name: string
filters: 
    [
        'FilterOne': 
            { 
                'FieldName': string, 
                'Argument': string 
            },
        'GreatherThen': 
            {
                'FieldName': string, 
                'Argument': string 
            },
        'GreatherThen': 
            {
                'FieldName': string, //e.g. Area
                'Argument': string  // 5
            },
    ]    
}

Methods

type ApplyFilter = ( geo: Geometry[] | Group[], filter: Filter ) => Group[]

//Preset list of functions for filtering
function string Containing (string input){
    // Finding all parameters containing input
} 
function string Equals (string input){
    // Finding all equaling input
}

type Filter = (geomety: Geometry[] | Group[], ...) => Group[]

// Example
function GreaterThen = (geometry, field:string, value:string ){
    
    groups = []
    
    if geometry[field] > float(value){
        
    }
    
    return groups 
}

Registry

class FilterRegistry {
    
    type GetFilter= (name:string) => Filter
    
    type RegistrFilter = (name:string, filter: Filter) => bool
}

interface FilterResult{
    // See config -> make it a refference. So the filters can be recreated from the goups
    filters: FilterList,
    groups: Group[] 
}

interface Group {
    id :    string
    name :  string
    //The path discribes hwo the categories will be displayed 
    path: string // discribes name/val/../val/name hierarchy eg. Wall/Inner Wall/Type 1
    elements: GeometryObjects[]
}

Connector

interface Querry {
    name: string
}

// Units for each phase and value
// Discussion point should we include this?
enum ImpactCategory {
    GWP,
    AP,
    ODP,
    EP,
    ...
}

const ImpactCategoryUnitMap = {
    GWP: "kg CO2-eq"
    ...
}

enum Phase {
    A,
    A1A3,
    A1,
    A2,
    A3,
    A4,
    A5,
    B1,
    B2,
    ...
}

interface Material {
    id:string
    name:string
    emmisions:Dict[ImpactCategory,Dict[Phase,number]] // -> GWP //Units see enum defined at filtrs
    country?:string
    subtype?: string // generic, specific, industry
    type?:string // Material type eg. Concrete, Wood etc
    url?:string // https://www.database.com/data.xml?objectID
    ...
}

Build up Creator

// Inherting from Material
interface Buildup extends Material {
    // Build in fuctions imitating a dictionary
    emmisions: Callable(unit:Unit) =>
        SumOfMaterialsByImpactCategory(impactCategory:ImpactCategory) =>
            SumOfMaterialsByPhase(phase:Phase) => number
    
    unit: Unit,
    build_up: [
        {
           material: Material //Material
           unit: Unit,
           factor: number //conversion from base to material unit
        },
        
    ]
}

Mapping

type ApplyMaterial = (allgroups: Group[], path_to_apply_material:string, material:Materila|Buildup) => MappedGeometry
type CheckCompatablilty = (groups: Group, material:Materila|Buildup) => bool

interface MappedGeometry extends GeometryObject{
    material: Material | Buildup
}

Calculation

type CalculateResults = (calculateAllCategories) => geometryWithResults

interface geometryWithResults extends MappendGeometry{
    results?: Results
}
interface Results {
    gwp?: ImpactCategory
    odp?: ImpactCategory
    ...
}
interface ImpactCategory {
a1a3?: number
a4?: number
    ...
}

Results

type SumResults = (SumResults) => projectResults

interface ProjectResults extends Project {
    results?: Results
}