LoopStructural 1.0.4__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/helper.py

@@ -0,0 +1,378 @@
+import logging
+
+import numpy as np
+from sklearn.decomposition import PCA
+
+logger = logging.getLogger(__name__)
+
+
+def get_data_axis_aligned_bounding_box(xyz, buffer):
+    """
+
+    Parameters
+    ----------
+    xyz
+    buffer
+
+    Returns
+    -------
+
+    """
+    minx = np.min(xyz[:, 0])
+    maxx = np.max(xyz[:, 0])
+    miny = np.min(xyz[:, 1])
+    maxy = np.max(xyz[:, 1])
+    minz = np.min(xyz[:, 2])
+    maxz = np.max(xyz[:, 2])
+
+    xlen = maxx - minx
+    ylen = maxy - miny
+    zlen = maxz - minz
+    length = np.max([xlen, ylen, zlen])
+    minx -= length * buffer
+    maxx += length * buffer
+
+    miny -= length * buffer
+    maxy += length * buffer
+
+    minz -= length * buffer
+    maxz += length * buffer
+
+    bb = np.array([[minx, miny, minz],
+                   [maxx, maxy, maxz]
+                   ])
+
+    def region(xyz):
+        """
+
+        Parameters
+        ----------
+        xyz
+
+        Returns
+        -------
+
+        """
+        # print(xyz)
+        # print(bb)
+        b = np.ones(xyz.shape[0]).astype(bool)
+        b = np.logical_and(b, xyz[:, 0] > minx)
+        b = np.logical_and(b, xyz[:, 0] < maxx)
+        b = np.logical_and(b, xyz[:, 1] > miny)
+        b = np.logical_and(b, xyz[:, 1] < maxy)
+        # b = np.logical_and(b,xyz[:,2]>minz)
+        # b = np.logical_and(b,xyz[:,2]<maxz)
+        return b
+
+    return bb, region
+
+def get_data_bounding_box_map(xyz, buffer):
+    """
+
+    Parameters
+    ----------
+    xyz
+    buffer
+
+    Returns
+    -------
+
+    """
+    # find the aligned coordinates box using pca
+    modelpca = PCA(n_components=3)
+    modelpca.fit(xyz)
+    # transform the data to this new coordinate then find extents
+    transformed_xyz = modelpca.transform(xyz)
+    minx = np.min(xyz[:, 0])
+    maxx = np.max(xyz[:, 0])
+    miny = np.min(xyz[:, 1])
+    maxy = np.max(xyz[:, 1])
+    minz = np.min(xyz[:, 2])
+    maxz = np.max(xyz[:, 2])
+
+    xlen = maxx - minx
+    ylen = maxy - miny
+    zlen = maxz - minz
+    length = np.max([xlen, ylen, zlen])
+    minx -= buffer
+    maxx += buffer
+
+    miny -= buffer
+    maxy += buffer
+
+    minz -= buffer
+    maxz += buffer
+
+    bb = np.array([[minx, miny, minz],
+                   [maxx, maxy, maxz]
+                   ])
+
+    def region(xyz):
+        b = np.ones(xyz.shape[0]).astype(bool)
+        b = np.logical_and(b, xyz[:, 0] > minx)
+        b = np.logical_and(b, xyz[:, 0] < maxx)
+        b = np.logical_and(b, xyz[:, 1] > miny)
+        b = np.logical_and(b, xyz[:, 1] < maxy)
+
+        return b
+
+    return bb, region
+def get_data_bounding_box(xyz, buffer):
+    """
+
+    Parameters
+    ----------
+    xyz
+    buffer
+
+    Returns
+    -------
+
+    """
+    # find the aligned coordinates box using pca
+    modelpca = PCA(n_components=3)
+    modelpca.fit(xyz)
+    # transform the data to this new coordinate then find extents
+    transformed_xyz = modelpca.transform(xyz)
+    minx = np.min(xyz[:, 0])
+    maxx = np.max(xyz[:, 0])
+    miny = np.min(xyz[:, 1])
+    maxy = np.max(xyz[:, 1])
+    minz = np.min(xyz[:, 2])
+    maxz = np.max(xyz[:, 2])
+
+    xlen = maxx - minx
+    ylen = maxy - miny
+    zlen = maxz - minz
+    length = np.max([xlen,ylen,zlen])
+    minx -= length * buffer
+    maxx += length * buffer
+
+    miny -= length * buffer
+    maxy += length * buffer
+
+    minz -= length * buffer
+    maxz += length * buffer
+
+    bb = np.array([[minx, miny, minz],
+                   [maxx, maxy, maxz]
+                   ])
+
+    def region(xyz):
+        b = np.ones(xyz.shape[0]).astype(bool)
+        b = np.logical_and(b, xyz[:, 0] > minx)
+        b = np.logical_and(b, xyz[:, 0] < maxx)
+        b = np.logical_and(b, xyz[:, 1] > miny)
+        b = np.logical_and(b, xyz[:, 1] < maxy)
+        b = np.logical_and(b, xyz[:, 2] > minz)
+        b = np.logical_and(b, xyz[:, 2] < maxz)
+        return b
+
+    return bb, region
+
+
+def plunge_and_plunge_dir_to_vector(plunge, plunge_dir):
+    plunge = np.deg2rad(plunge)
+    plunge_dir = np.deg2rad(plunge_dir)
+    vec = np.zeros(3)
+    vec[0] = np.sin(plunge_dir) * np.cos(plunge)
+    vec[1] = np.cos(plunge_dir) * np.cos(plunge)
+    vec[2] = -np.sin(plunge)
+    return vec
+
+
+def create_surface(bounding_box, nstep):
+    x = np.linspace(bounding_box[0, 0], bounding_box[1, 0], nstep[0])  #
+    y = np.linspace(bounding_box[0, 1], bounding_box[1, 1], nstep[1])
+    xx, yy = np.meshgrid(x, y, indexing='xy')
+
+    def gi(i, j):
+        return i + j * nstep[0]
+
+    corners = np.array([[0, 1, 0, 1], [0, 0, 1, 1]])
+    i = np.arange(0, nstep[0] - 1)
+
+    j = np.arange(0, nstep[1] - 1)
+    ii, jj = np.meshgrid(i, j, indexing='ij')
+    corner_gi = gi(ii[:, :, None] + corners[None, None, 0, :, ],
+                   jj[:, :, None] + corners[None, None, 1, :, ])
+    corner_gi = corner_gi.reshape((nstep[0] - 1) * (nstep[1] - 1), 4)
+    tri = np.vstack([corner_gi[:, :3], corner_gi[:, 1:]])
+    return tri, xx.flatten(), yy.flatten()
+
+def create_box(bounding_box, nsteps):
+    tri, xx, yy = create_surface(bounding_box[0:2, :], nsteps[0:2])
+
+    zz = np.zeros(xx.shape)
+    zz[:] = bounding_box[1, 2]
+
+    tri = np.vstack([tri, tri + np.max(tri) + 1])
+    xx = np.hstack([xx, xx])
+    yy = np.hstack([yy, yy])
+
+    z = np.zeros(zz.shape)
+    z[:] = bounding_box[0, 2]
+    zz = np.hstack([zz, z])
+    # y faces
+    t, x, z = create_surface(bounding_box[:, [0, 2]], nsteps[[0, 2]])
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+
+    y = np.zeros(x.shape)
+    y[:] = bounding_box[0, 1]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+    y[:] = bounding_box[1, 1]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    # x faces
+    t, y, z = create_surface(bounding_box[:, [1, 2]], nsteps[[1, 2]])
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+    x = np.zeros(y.shape)
+    x[:] = bounding_box[0, 0]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+    x[:] = bounding_box[1, 0]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    points = np.zeros((len(xx), 3))  #
+    points[:, 0] = xx
+    points[:, 1] = yy
+    points[:, 2] = zz
+    return points, tri
+
+def get_vectors(normal):
+    length =  np.linalg.norm(normal,axis=1)[:,None]
+    normal /= length#np.linalg.norm(normal,axis=1)[:,None]
+    strikedip = normal_vector_to_strike_and_dip(normal)
+    strike_vec = get_strike_vector(strikedip[:, 0])
+    strike_vec /= np.linalg.norm(strike_vec,axis=0)[None,:]
+    dip_vec = np.cross(strike_vec, normal, axisa=0, axisb=1).T  # (strikedip[:, 0], strikedip[:, 1])
+    dip_vec /= np.linalg.norm(dip_vec,axis=0)[None,:]
+    return strike_vec*length.T, dip_vec*length.T
+
+
+def get_strike_vector(strike):
+    """
+
+    Parameters
+    ----------
+    strike
+
+    Returns
+    -------
+
+    """
+
+    v = np.array([np.sin(np.deg2rad(-strike)),
+                  -np.cos(np.deg2rad(-strike)),
+                  np.zeros(strike.shape[0])
+                  ])
+
+    return v
+
+
+def get_dip_vector(strike, dip):
+    v = np.array([-np.cos(np.deg2rad(-strike)) * np.cos(-np.deg2rad(dip)),
+                  np.sin(np.deg2rad(-strike)) * np.cos(-np.deg2rad(dip)),
+                  np.sin(-np.deg2rad(dip))
+                  ])
+    return v
+
+
+def rotation(axis, angle):
+    c = np.cos(np.deg2rad(angle))
+    s = np.sin((np.deg2rad(angle)))
+    C = 1.0 - c
+    x = axis[0]
+    y = axis[1]
+    z = axis[2]
+    xs = x * s
+    ys = y * s
+    zs = z * s
+    xC = x * C
+    yC = y * C
+    zC = z * C
+    xyC = x * yC
+    yzC = y * zC
+    zxC = z * xC
+    rotation_mat = np.zeros((3, 3))
+    rotation_mat[0][0] = x * xC + c
+    rotation_mat[0][1] = xyC - zs
+    rotation_mat[0][2] = zxC + ys
+
+    rotation_mat[1][0] = xyC + zs
+    rotation_mat[1][1] = y * yC + c
+    rotation_mat[1][2] = yzC - xs
+
+    rotation_mat[2][0] = zxC - ys
+    rotation_mat[2][1] = yzC + xs
+    rotation_mat[2][2] = z * zC + c
+    return rotation_mat
+
+
+def strike_dip_vector(strike, dip):
+    vec = np.zeros((len(strike), 3))
+    s_r = np.deg2rad(strike)
+    d_r = np.deg2rad((dip))
+    vec[:, 0] = np.sin(d_r) * np.cos(s_r)
+    vec[:, 1] = -np.sin(d_r) * np.sin(s_r)
+    vec[:, 2] = np.cos(d_r)
+    vec /= np.linalg.norm(vec, axis=1)[:, None]
+    return vec
+
+
+def normal_vector_to_strike_and_dip(normal_vector):
+    normal_vector /= np.linalg.norm(normal_vector, axis=1)[:, None]
+    dip = np.rad2deg(np.arccos(normal_vector[:, 2]))
+    strike = -np.rad2deg(np.arctan2(normal_vector[:, 1], normal_vector[:,
+                                                         0]))  # atan2(v2[1],v2[0])*rad2deg;
+
+    return np.array([strike, dip]).T
+
+
+def xyz_names():
+    return ['X', 'Y', 'Z']
+
+
+def normal_vec_names():
+    return ['nx', 'ny', 'nz']
+
+
+def tangent_vec_names():
+    return ['tx', 'ty', 'tz']
+
+
+def gradient_vec_names():
+    return ['gx', 'gy', 'gz']
+
+
+def weight_name():
+    return ['w']
+
+
+def val_name():
+    return ['val']
+
+def coord_name():
+    return ['coord']
+
+def interface_name():
+    return ['interface']
+
+
+def feature_name():
+    return ['feature_name']
+
+def all_heading():
+    return xyz_names() + normal_vec_names() + tangent_vec_names() + \
+           gradient_vec_names() + weight_name() + val_name() + coord_name() + feature_name() + interface_name()

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/map2loop.py

@@ -0,0 +1,314 @@
+import pandas as pd
+import numpy as np
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+def process_map2loop(m2l_directory, flags={}):
+    """
+    Extracts relevant information from map2loop outputs
+
+    Parameters
+    ----------
+    m2l_directory : string
+        absolute path to a directory containing map2loop outputs
+    Returns
+    -------
+    m2l_data : dict
+        a dictionary containing the extracted and collated data
+    """
+    gradient = flags.get('gradient',False)
+    vector_scale = flags.get('vector_scale',None)
+    tangents = pd.read_csv(m2l_directory + '/tmp/raw_contacts.csv')
+    groups = pd.read_csv(m2l_directory + '/tmp/all_sorts_clean.csv', index_col=0)
+    contact_orientations = pd.read_csv(m2l_directory + '/output/orientations_clean.csv')
+    # formation_thickness = pd.read_csv)
+    contacts = pd.read_csv(m2l_directory + '/output/contacts_clean.csv')
+    displacements = pd.read_csv(m2l_directory + '/output/fault_displacements3.csv')
+    fault_orientations = pd.read_csv(m2l_directory + '/output/fault_orientations.csv')
+    fault_locations = pd.read_csv(m2l_directory + '/output/faults.csv')
+    fault_fault_relations = pd.read_csv(m2l_directory + '/output/fault-fault-relationships.csv')
+    fault_strat_relations = pd.read_csv(m2l_directory + '/output/group-fault-relationships.csv')
+    fault_dimensions = pd.read_csv(m2l_directory + '/output/fault_dimensions.csv')
+
+    supergroups = {}
+    sgi = 0
+    try:
+        with open(m2l_directory + '/tmp/super_groups.csv') as    f:
+            for l in f:
+                for g in l.split(','):
+                    g = g.replace('-','_').replace(' ','_')
+                    if g.find('\n') > 0:
+                        g = g[:g.find('\n')]
+                    supergroups[g] = 'supergroup_{}'.format(sgi)
+                    if g == '\n':
+                        sgi += 1
+                        break
+    except:
+        for g in groups['group'].unique():
+            supergroups[g] = g
+    try:
+        supergroups.pop('\n')
+    except KeyError:
+        pass
+    
+
+    bb = pd.read_csv(m2l_directory+'/tmp/bbox.csv')
+
+    # process tangent data to be tx, ty, tz
+    tangents['tz'] = 0
+    tangents['tx'] = tangents['lsx']
+    tangents['ty'] = tangents['lsy']
+    tangents.drop(['angle', 'lsx', 'lsy'], inplace=True, axis=1)
+
+    # convert azimuth and dip to gx, gy, gz
+    
+
+    # calculate scalar field values
+    i = 0
+    thickness = {}
+    max_thickness = 0
+    thickness_file = flags.get('thickness',m2l_directory + '/output/formation_summary_thicknesses.csv')
+    with open(thickness_file) as file:
+        for l in file:
+            if i>=1:
+                linesplit = l.split(',')
+                thickness[linesplit[0]] = float(linesplit[1])
+                # normalise the thicknesses
+                if float(linesplit[1]) > max_thickness:
+                    max_thickness=float(linesplit[1])
+    #             print(l.split(',')[1])
+            i+=1
+    # for k in thickness.keys():
+    #     thickness[k] /= max_thickness
+    if vector_scale is None:
+        vector_scale = max_thickness
+
+    if gradient:
+        from LoopStructural.utils.helper import strike_dip_vector
+        contact_orientations['strike'] = contact_orientations['azimuth'] - 90
+        contact_orientations['gx'] = np.nan
+        contact_orientations['gy'] = np.nan
+        contact_orientations['gz'] = np.nan
+        contact_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(contact_orientations['strike'],
+                                                                    contact_orientations['dip'])*max_thickness 
+    if not gradient:
+        from LoopStructural.utils.helper import strike_dip_vector
+        contact_orientations['strike'] = contact_orientations['azimuth'] - 90
+        contact_orientations['nx'] = np.nan
+        contact_orientations['ny'] = np.nan
+        contact_orientations['nz'] = np.nan
+        contact_orientations[['nx', 'ny', 'nz']] = strike_dip_vector(contact_orientations['strike'],
+                                                                    contact_orientations['dip'])*vector_scale *contact_orientations['polarity'].to_numpy()[:,None]
+    contact_orientations.drop(['strike', 'dip', 'azimuth'], inplace=True, axis=1)
+    # with open(m2l_directory + '/output/formation_summary_thicknesses.csv') as file:
+
+    # thickness = {}
+    # for f in formation_thickness['formation'].unique():
+    #     thickness[f] = formation_thickness[formation_thickness['formation'] == f]['thickness'])
+
+    strat_val = {}
+    stratigraphic_column = {}
+    unit_id = 0
+    val = {}
+    for i in groups['group number'].unique():
+        g = supergroups[groups.loc[groups['group number'] == i, 'group'].iloc[0]]
+        if g not in stratigraphic_column:
+            stratigraphic_column[g] = {}
+            val[g] = 0
+
+        for c, colour in zip(groups.loc[groups['group number'] == i, 'code'],groups.loc[groups['group number'] == i, 'colour']):
+            strat_val[c] = np.nan
+            if c in thickness:
+                stratigraphic_column[g][c] = {'max': val[g], 'min': val[g] - thickness[c], 'id': unit_id, 'colour':colour}
+                unit_id += 1
+                strat_val[c] = val[g] - thickness[c]
+                val[g] -= thickness[c]
+    group_name = None
+    for g, i in stratigraphic_column.items():
+        if len(i) ==0:
+            for gr, sg in supergroups.items():
+                if sg == g:
+                    group_name = gr
+                    break
+            try:
+                if group_name is None:
+                    continue
+                c=groups.loc[groups['group']==group_name,'code'].to_numpy()[0]
+                strat_val[c] = 0
+                stratigraphic_column[g] = {c:{'min':0,'max':9999,'id':unit_id}}
+                unit_id+=1
+                group_name = None
+            except:
+                print('Couldnt process {}'.format(g))
+    contacts['val'] = np.nan
+    for o in strat_val:
+        contacts.loc[contacts['formation'] == o, 'val'] = strat_val[o]
+
+    tangents['feature_name'] = tangents['group']
+    contact_orientations['feature_name'] = None
+    contacts['feature_name'] = None
+    for g in groups['group'].unique():
+        val = 0
+        for c in groups.loc[groups['group'] == g, 'code']:
+            contact_orientations.loc[contact_orientations['formation'] == c, 'feature_name'] = supergroups[g]
+            contacts.loc[contacts['formation'] == c, 'feature_name'] = supergroups[g]
+    displacements['dip_dir'] = np.nan
+    for fname in fault_orientations['formation'].unique():
+        displacements.loc[displacements['fname'] == fname, 'dip_dir'] = np.mean(
+            fault_orientations.loc[fault_orientations['formation'] == fname, 'DipDirection'])
+    max_displacement = {}
+    downthrow_dir = {}
+    fault_locations['val'] = 0
+    fault_locations['coord'] = 0
+    fault_orientations['coord'] = 0
+    fault_orientations['gx'] = np.nan
+    fault_orientations['gy'] = np.nan
+    fault_orientations['gz'] = np.nan
+
+
+    for f in displacements['fname'].unique():
+        fault_centers = np.zeros(6)
+        normal_vector = np.zeros(3)
+        strike_vector = np.zeros(3)
+        slip_vector = np.zeros(3)
+
+        fault_edges = np.zeros((2,3))
+        fault_tips = np.zeros((2,3))
+        fault_depth = np.zeros((2,3))
+        displacements_numpy = displacements.loc[
+            displacements['fname'] == f, ['vertical_displacement', 'downthrow_dir', 'dip_dir','X','Y']].to_numpy()
+        # index = np.argmax(np.abs(displacements_numpy[:, 0]), )
+        index = np.argsort(np.abs(displacements_numpy[:, 0]))[len(np.abs(displacements_numpy[:, 0]))//2]
+        
+        max_displacement[f] = displacements_numpy[
+            index, 0]
+        downthrow_dir[f] = displacements_numpy[index,[1,3,4]]
+        if np.abs(displacements_numpy[index, 1] - displacements_numpy[index, 2]) > 90:
+            # fault_orientations.loc[fault_orientations['formation'] == f, ['gx','gy','gy']]=-fault_orientations.loc[fault_orientations['formation'] == f, ['gx','gy','gy']]
+            fault_orientations.loc[fault_orientations['formation'] == f, 'DipDirection'] -= 180#displacements_numpy[
+                # index, 1]
+        # find the middle of the fault as the mean of the line, average dip direction and the influence distance
+        fault_centers[:3] = np.mean(fault_locations.loc[fault_locations['formation']==f,['X','Y','Z']],axis=0)
+        fault_centers[3] = np.mean(fault_orientations.loc[fault_orientations['formation']==f,['DipDirection']])
+        fault_centers[4] = fault_dimensions.loc[fault_dimensions['Fault']==f,'InfluenceDistance']
+        fault_centers[5] = fault_dimensions.loc[fault_dimensions['Fault']==f,'HorizontalRadius']
+        normal_vector[0] = np.sin(np.deg2rad(fault_centers[3]))
+        normal_vector[1] = np.cos(np.deg2rad(fault_centers[3]))
+        strike_vector[0] = normal_vector[1]
+        strike_vector[1] = -normal_vector[0]
+        slip_vector[2]=1
+        fault_edges[0,:] = fault_centers[:3]+normal_vector*fault_centers[4]
+        fault_edges[1,:] = fault_centers[:3]-normal_vector*fault_centers[4]
+        fault_tips[0,:] = fault_centers[:3]+strike_vector*fault_centers[5]
+        fault_tips[1,:] = fault_centers[:3]-strike_vector*fault_centers[5]
+        # fault_depth[0,:] = fault_centers[:3]+slip_vector*fault_centers[5]
+        # fault_depth[1,:] = fault_centers[:3]-slip_vector*fault_centers[5]
+        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_edges[0,0],fault_edges[0,1],fault_edges[0,2],f,1,0]
+        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_edges[1,0],fault_edges[1,1],fault_edges[1,2],f,-1,0]
+        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_tips[0,0],fault_tips[0,1],fault_tips[0,2],f,1,2]
+        fault_locations.loc[len(fault_locations),['X','Y','Z','formation','val','coord']] = [fault_tips[1,0],fault_tips[1,1],fault_tips[1,2],f,-1,2]
+        # add strike vector to constraint fault extent
+        fault_orientations.loc[len(fault_orientations),['X','Y','Z','formation','DipDirection','coord']] = [fault_centers[0],fault_centers[1],fault_centers[2],f, fault_centers[3]-90,2]
+        fault_orientations.loc[len(fault_orientations),['X','Y','Z','formation','dip','coord']] = [fault_centers[0],fault_centers[1],fault_centers[2],f, 0,2]
+
+        # print('downthro',displacements_numpy[index, 1])
+        
+    fault_orientations['strike'] = fault_orientations['DipDirection'] - 90
+    fault_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(fault_orientations['strike'], fault_orientations['dip'])
+
+    for g in groups['group'].unique():
+        groups.loc[groups['group']==g,'group'] = supergroups[g]
+    # fault_orientations['strike'] = fault_orientations['DipDirection'] - 90
+    # fault_orientations['gx'] = np.nan
+    # fault_orientations['gy'] = np.nan
+    # fault_orientations['gz'] = np.nan
+
+    fault_orientations.drop(['strike', 'DipDirection', 'dip', 'DipPolarity'], inplace=True, axis=1)
+    fault_orientations['feature_name'] = fault_orientations['formation']
+    fault_locations['feature_name'] = fault_locations['formation']
+
+    
+
+    data = pd.concat([tangents, contact_orientations, contacts, fault_orientations, fault_locations])
+    data.reset_index()
+
+    return {'data': data,
+            'groups': groups,
+            'max_displacement': max_displacement,
+            'fault_fault': fault_fault_relations,
+            'stratigraphic_column': stratigraphic_column,
+            'bounding_box':bb,
+            'strat_va':strat_val,
+            'downthrow_dir':downthrow_dir}
+
+def build_model(m2l_data, skip_faults = False, unconformities=False, fault_params = None, foliation_params=None, rescale = True,**kwargs):
+    """[summary]
+
+    [extended_summary]
+
+    Parameters
+    ----------
+    m2l_data : dict
+        [description]
+    skip_faults : bool, optional
+        [description], by default False
+    fault_params : dict, optional
+        [description], by default None
+    foliation_params : dict, optional
+        [description], by default None
+
+    Returns
+    -------
+    [type]
+        [description]
+    """
+    from LoopStructural import GeologicalModel
+
+
+    boundary_points = np.zeros((2, 3))
+    boundary_points[0, 0] = m2l_data['bounding_box']['minx']
+    boundary_points[0, 1] = m2l_data['bounding_box']['miny']
+    boundary_points[0, 2] = m2l_data['bounding_box']['lower']
+    boundary_points[1, 0] = m2l_data['bounding_box']['maxx']
+    boundary_points[1, 1] = m2l_data['bounding_box']['maxy']
+    boundary_points[1, 2] = m2l_data['bounding_box']['upper']
+
+    model = GeologicalModel(boundary_points[0, :], boundary_points[1, :], rescale=rescale)
+    # m2l_data['data']['val'] /= model.scale_factor
+    model.set_model_data(m2l_data['data'])
+    if not skip_faults:
+        faults = []
+        for f in m2l_data['max_displacement'].keys():
+            if model.data[model.data['feature_name'] == f].shape[0] == 0:
+                continue
+            fault_id = f
+            overprints = []
+            try:
+                overprint_id = m2l_data['fault_fault'][m2l_data['fault_fault'][fault_id] == 1]['fault_id'].to_numpy()
+                for i in overprint_id:
+                    overprints.append(i)
+                logger.info('Adding fault overprints {}'.format(f))
+            except:
+                logger.info('No entry for %s in fault_fault_relations' % f)
+        #     continue
+            faults.append(model.create_and_add_fault(f,
+                                                    -m2l_data['max_displacement'][f],
+                                                    faultfunction='BaseFault',
+                                                    overprints=overprints,
+                                                    **fault_params,
+                                                    )
+                        )
+
+    ## loop through all of the groups and add them to the model in youngest to oldest.
+    group_features = []
+    for i in np.sort(m2l_data['groups']['group number'].unique()):
+        g = m2l_data['groups'].loc[m2l_data['groups']['group number'] == i, 'group'].unique()[0]
+        group_features.append(model.create_and_add_foliation(g,
+                                                            **foliation_params))
+        # if the group was successfully added (not null) then lets add the base (0 to be unconformity)
+        if group_features[-1] and unconformities:
+            model.add_unconformity(group_features[-1], 0)
+    model.set_stratigraphic_column(m2l_data['stratigraphic_column'])
+    return model