Skip to content
Snippets Groups Projects
Commit 63916228 authored by David's avatar David
Browse files

automate generation of pc-S relation ship dicts with functions module. clean up five patch example

parent e2658800
No related branches found
No related tags found
No related merge requests found
......@@ -8,6 +8,7 @@ import typing as tp
import dolfin as df
import functools as ft
# RELATIVE PERMEABILITIES #####################################################
# Functions used as relative permeabilty functions for wetting phases
def SpowN(S,N):
return S**N
......@@ -76,93 +77,92 @@ def generate_relative_permeability_dicts(
raise(NotImplementedError())
return output
# class SpcRelation(object):
# """provide capillary pressure saturation relationships functions."""
# def __init__(self, Spc_on_subdomains):
# """build base fuction dictionary"""
# self._build_base_dict()
# self._Spc_on_subdomains = Spc_on_subdomains
# self._build_callables()
#
# def _build_base_dict(self):
# """Build base dictionary."""
# self.__Spc = {
# "testSpc": self.testSpc(),
# }
#
# def _build_callables(self):
# """Build callable dictionaries."""
# self.symbolic = dict()
# self.prime_symbolic = dict()
# self.dolfin = dict()
#
# for subdomain, Spc_dict in self._Spc_on_subdomains.items():
# for Spc_type, parameters in Spc_dict.items():
# if Spc_type == "testSpc":
# self.symbolic.update(
# {subdomain: ft.partialmethod(
# self.__Spc[Spc_type].S_sym,
# index=parameters["index"]
# )},
# )
# self.prime_symbolic.update(
# {subdomain: ft.partial(
# self.__Spc[Spc_type].S_prime_sym,
# index=parameters["index"]
# )},
# )
# self.dolfin.update(
# {subdomain: ft.partial(
# self.__Spc[Spc_type].S,
# index=parameters["index"]
# )},
# )
# elif Spc_type == "vanGenuchten":
# raise(NotImplementedError())
# else:
# raise(NotImplementedError())
#
# class testSpc(object):
# """Test S-pc relationship used in R-R paper."""
#
# def __init__(self):
# """Construct testSpc."""
# print("testSpc")
#
# def S(pc, index):
# """Inverse capillary pressure-saturation-relationship.
#
# Inverse capillary pressure-saturation-relationship that will
# be used by the simulation class
# this function needs to be monotonically decreasing in the
# capillary_pressure. Since in the richards case pc=-pw, this
# becomes as a function of pw a monotonically INCREASING function
# like in our Richards-Richards paper.
# However since we unify the treatment in the
# code for Richards and two-phase, we need the same requierment
# for both cases, two-phase and Richards.
# """
# # inverse capillary pressure-saturation-relationship
# return df.conditional(pc > 0, 1/((1 + pc)**(1/(index + 1))), 1)
#
# def S_sym(pc, index):
# """Inverse capillary pressure-saturation-relationship.
#
# Inverse capillary pressure-saturation-relationship as symbolic
# expression, that will be used by
# helpers.generate_exact_solution_expressions()
# """
# # inverse capillary pressure-saturation-relationship
# return 1/((1 + pc)**(1/(index + 1)))
#
# # derivative of S-pc relationship with respect to pc.
# # This is needed for the construction of a analytic solution.
# def S_prime_sym(pc, index):
# """Derivative of inverse pc-S-relationship.
#
# Derivative of the inverse pc-S-relationship as symbolic
# expression, that will be used by
# helpers.generate_exact_solution_expressions()
# """
# # inverse capillary pressure-saturation-relationship
# return -1/((index+1)*(1 + pc)**((index+2)/(index+1)))
# S-Pc RELATIONSHIPS ##########################################################
def test_S(pc, index):
"""Inverse capillary pressure-saturation-relationship.
Inverse capillary pressure-saturation-relationship that will
be used by the simulation class
this function needs to be monotonically decreasing in the
capillary_pressure. Since in the richards case pc=-pw, this
becomes as a function of pw a monotonically INCREASING function
like in our Richards-Richards paper.
However since we unify the treatment in the
code for Richards and two-phase, we need the same requierment
for both cases, two-phase and Richards.
"""
# inverse capillary pressure-saturation-relationship
return df.conditional(pc > 0, 1/((1 + pc)**(1/(index + 1))), 1)
def test_S_sym(pc, index):
"""Inverse capillary pressure-saturation-relationship.
Inverse capillary pressure-saturation-relationship as symbolic
expression, that will be used by
helpers.generate_exact_solution_expressions()
"""
# inverse capillary pressure-saturation-relationship
return 1/((1 + pc)**(1/(index + 1)))
# derivative of S-pc relationship with respect to pc.
# This is needed for the construction of a analytic solution.
def test_S_prime_sym(pc, index):
"""Derivative of inverse pc-S-relationship.
Derivative of the inverse pc-S-relationship as symbolic
expression, that will be used by
helpers.generate_exact_solution_expressions()
"""
# inverse capillary pressure-saturation-relationship
return -1/((index+1)*(1 + pc)**((index+2)/(index+1)))
def generate_Spc_dicts(
Spc_on_subdomains: tp.Dict[int, tp.Dict[str, tp.Dict[str, float]]]
)-> tp.Dict[str, tp.Dict[int, tp.Callable]]:
"""Generate S-pc dictionaries from definition dict.
Generate S-pc dictionaries from input definition dictionary
Spc_on_subdomains. This dictionary contains for each subdomain a
dictionary which in turn contains as key a descriptive string
describing which function should be used as S-pc relation for that
particular subdomain. The values are parameters for that function type
e.g. in the case of Van Genuchten or Brooks and Correy.
The supported cases are defined by the if statements
below.
The output is a dictionary containing three dictionaries, the S-pc
relationship for the simulation class as well as a symbolic version and
its derivative for exact solution generation.
"""
output = dict()
output.update({"symbolic": dict()})
output.update({"prime_symbolic": dict()})
output.update({"dolfin": dict()})
for subdomain, Spc_dict in Spc_on_subdomains.items():
for Spc_type, parameters in Spc_dict.items():
if Spc_type == "testSpc":
output["symbolic"].update(
{subdomain: ft.partial(
test_S_sym,
index=parameters["index"]
)},
)
output["prime_symbolic"].update(
{subdomain: ft.partial(
test_S_prime_sym,
index=parameters["index"]
)},
)
output["dolfin"].update(
{subdomain: ft.partial(
test_S,
index=parameters["index"]
)},
)
elif Spc_type == "vanGenuchten":
raise(NotImplementedError())
else:
raise(NotImplementedError())
return output
......@@ -5,13 +5,11 @@ This program sets up an LDD simulation
"""
import dolfin as df
import sympy as sym
import functools as ft
import functions as fts
import LDDsimulation as ldd
import helpers as hlp
import datetime
import os
import pandas as pd
import multiprocessing as mp
import domainSubstructuring as dss
......@@ -274,7 +272,7 @@ intrinsic_permeability = {
6: 0.01, #10e-3
}
# rel_perm_generator = func.relative_permeability()
# relative permeabilties
rel_perm_definition = {
1: {"wetting": "Spow2",
"nonwetting": "oneMinusSpow2"},
......@@ -292,66 +290,18 @@ rel_perm_dict = fts.generate_relative_permeability_dicts(rel_perm_definition)
relative_permeability = rel_perm_dict["ka"]
ka_prime = rel_perm_dict["ka_prime"]
# Spc_on_subdomains = {
# 1: {"testSpc": {"index": 1}},
# 2: {"testSpc": {"index": 2}},
# 3: {"testSpc": {"index": 2}},
# 4: {"testSpc": {"index": 2}},
# 5: {"testSpc": {"index": 1}}
# }
# Spc = fts.SpcRelation(Spc_on_subdomains)
# S_pc_sym = Spc.symbolic
# S_pc_sym_prime = Spc.prime_symbolic
# sat_pressure_relationship = Spc.dolfin
# this function needs to be monotonically decreasing in the capillary_pressure.
# since in the richards case pc=-pw, this becomes as a function of pw a mono
# tonically INCREASING function like in our Richards-Richards paper. However
# since we unify the treatment in the code for Richards and two-phase, we need
# the same requierment
# for both cases, two-phase and Richards.
def saturation(pc, index):
# inverse capillary pressure-saturation-relationship
return df.conditional(pc > 0, 1/((1 + pc)**(1/(index + 1))), 1)
def saturation_sym(pc, index):
# inverse capillary pressure-saturation-relationship
return 1/((1 + pc)**(1/(index + 1)))
# derivative of S-pc relationship with respect to pc. This is needed for the
# construction of a analytic solution.
def saturation_sym_prime(pc, index):
# inverse capillary pressure-saturation-relationship
return -1/((index+1)*(1 + pc)**((index+2)/(index+1)))
# note that the conditional definition of S-pc in the nonsymbolic part will be
# incorporated in the construction of the exact solution below.
S_pc_sym = {
1: ft.partial(saturation_sym, index=1),
2: ft.partial(saturation_sym, index=2),
3: ft.partial(saturation_sym, index=2),
4: ft.partial(saturation_sym, index=2),
5: ft.partial(saturation_sym, index=1)
}
S_pc_sym_prime = {
1: ft.partial(saturation_sym_prime, index=1),
2: ft.partial(saturation_sym_prime, index=2),
3: ft.partial(saturation_sym_prime, index=2),
4: ft.partial(saturation_sym_prime, index=2),
5: ft.partial(saturation_sym_prime, index=1)
}
sat_pressure_relationship = {
1: ft.partial(saturation, index=1),
2: ft.partial(saturation, index=2),
3: ft.partial(saturation, index=2),
4: ft.partial(saturation, index=2),
5: ft.partial(saturation, index=1)
# S-pc relation
Spc_on_subdomains = {
1: {"testSpc": {"index": 1}},
2: {"testSpc": {"index": 2}},
3: {"testSpc": {"index": 2}},
4: {"testSpc": {"index": 2}},
5: {"testSpc": {"index": 1}}
}
Spc = fts.generate_Spc_dicts(Spc_on_subdomains)
S_pc_sym = Spc["symbolic"]
S_pc_sym_prime = Spc["prime_symbolic"]
sat_pressure_relationship = Spc["dolfin"]
#############################################
# Manufacture source expressions with sympy #
......
#!/usr/bin/python3
"""Multi-patch simulation with inner patch.
This program sets up an LDD simulation
"""
import dolfin as df
import sympy as sym
import functions as fts
import LDDsimulation as ldd
import helpers as hlp
import datetime
import os
import multiprocessing as mp
import domainSubstructuring as dss
# init sympy session
sym.init_printing()
# PREREQUISITS ###############################################################
# check if output directory "./output" exists. This will be used in
# the generation of the output string.
if not os.path.exists('./output'):
os.mkdir('./output')
print("Directory ", './output', " created ")
else:
print("Directory ", './output', " already exists. Will use as output \
directory")
date = datetime.datetime.now()
datestr = date.strftime("%Y-%m-%d")
# Name of the usecase that will be printed during simulation.
use_case = "TP-R-five-domain-with-inner-patch-realistic"
# The name of this very file. Needed for creating log output.
thisfile = "TP-R-multi-patch-with-inner-patch.py"
# GENERAL SOLVER CONFIG ######################################################
# maximal iteration per timestep
max_iter_num = 1000
FEM_Lagrange_degree = 1
# GRID AND MESH STUDY SPECIFICATIONS #########################################
mesh_study = True
resolutions = {
1: 5e-5,
2: 5e-5,
4: 2e-5,
8: 2e-5,
16: 5e-6,
32: 5e-6,
64: 3e-6,
128: 3e-6,
# 256: 1e-6,
}
# starttimes gives a list of starttimes to run the simulation from.
# The list is looped over and a simulation is run with t_0 as initial time
# for each element t_0 in starttimes.
starttimes = [0.0]
timestep_size = 0.001
number_of_timesteps = 1000
# LDD scheme parameters ######################################################
Lw1 = 0.5 # /timestep_size
Lnw1 = Lw1
Lw2 = 0.5 # /timestep_size
Lnw2 = Lw2
Lw3 = 0.5 # /timestep_size
Lnw3 = Lw3
Lw4 = 0.5 # /timestep_size
Lnw4 = Lw4
Lw5 = 0.5 # /timestep_size
Lnw5 = Lw5
lambda13_w= 4
lambda13_nw= 4
lambda12_w = 4
lambda12_nw = 4
lambda23_w = 4
lambda23_nw = 4
lambda24_w = 4
lambda24_nw= 4
lambda34_w = 4
lambda34_nw = 4
lambda45_w = 4
lambda45_nw = 4
lambda15_w = 4
lambda15_nw = 4
include_gravity = True
debugflag = False
analyse_condition = False
# I/O CONFIG #################################################################
# when number_of_timesteps is high, it might take a long time to write all
# timesteps to disk. Therefore, you can choose to only write data of every
# plot_timestep_every timestep to disk.
plot_timestep_every = 4
# Decide how many timesteps you want analysed. Analysed means, that
# subsequent errors of the L-iteration within the timestep are written out.
number_of_timesteps_to_analyse = 8
# fine grained control over data to be written to disk in the mesh study case
# as well as for a regular simuation for a fixed grid.
if mesh_study:
write_to_file = {
# output the relative errornorm (integration in space) w.r.t. an exact
# solution for each timestep into a csv file.
'space_errornorms': True,
# save the mesh and marker functions to disk
'meshes_and_markers': True,
# save xdmf/h5 data for each LDD iteration for timesteps determined by
# number_of_timesteps_to_analyse. I/O intensive!
'L_iterations_per_timestep': False,
# save solution to xdmf/h5.
'solutions': True,
# save absolute differences w.r.t an exact solution to xdmf/h5 file
# to monitor where on the domains errors happen
'absolute_differences': True,
# analyise condition numbers for timesteps determined by
# number_of_timesteps_to_analyse and save them over time to csv.
'condition_numbers': analyse_condition,
# output subsequent iteration errors measured in L^2 to csv for
# timesteps determined by number_of_timesteps_to_analyse.
# Usefull to monitor convergence of the acutal LDD solver.
'subsequent_errors': True
}
else:
write_to_file = {
'space_errornorms': True,
'meshes_and_markers': True,
'L_iterations_per_timestep': False,
'solutions': True,
'absolute_differences': True,
'condition_numbers': analyse_condition,
'subsequent_errors': True
}
# OUTPUT FILE STRING #########################################################
output_string = "./output/{}-{}_timesteps{}_P{}".format(
datestr, use_case, number_of_timesteps, FEM_Lagrange_degree
)
# DOMAIN AND INTERFACE #######################################################
substructuring = dss.chessBoardInnerPatch()
interface_def_points = substructuring.interface_def_points
adjacent_subdomains = substructuring.adjacent_subdomains
subdomain_def_points = substructuring.subdomain_def_points
outer_boundary_def_points = substructuring.outer_boundary_def_points
# MODEL CONFIGURATION #########################################################
isRichards = {
1: True,
2: False,
3: False,
4: False,
5: True,
}
# isRichards = {
# 1: True,
# 2: True,
# 3: True,
# 4: True,
# 5: True,
# 6: True
# }
# Dict of the form: { subdom_num : viscosity }
viscosity = {
1: {'wetting' :1,
'nonwetting': 1/50},
2: {'wetting' :1,
'nonwetting': 1/50},
3: {'wetting' :1,
'nonwetting': 1/50},
4: {'wetting' :1,
'nonwetting': 1/50},
5: {'wetting' :1,
'nonwetting': 1/50},
}
# Dict of the form: { subdom_num : density }
densities = {
1: {'wetting': 997.0, #997
'nonwetting': 1.225}, #1}, #1.225},
2: {'wetting': 997.0, #997
'nonwetting': 1.225}, #1.225},
3: {'wetting': 997.0, #997
'nonwetting': 1.225}, #1.225},
4: {'wetting': 997.0, #997
'nonwetting': 1.225}, #1.225}
5: {'wetting': 997.0, #997
'nonwetting': 1.225}, #1.225},
}
gravity_acceleration = 9.81
# porosities taken from
# https://www.geotechdata.info/parameter/soil-porosity.html
# Dict of the form: { subdom_num : porosity }
porosity = {
1: 0.2, #0.2, # Clayey gravels, clayey sandy gravels
2: 0.2, #0.22, # Silty gravels, silty sandy gravels
3: 0.2, #0.37, # Clayey sands
4: 0.2, #0.2 # Silty or sandy clay
5: 0.2, #
}
# subdom_num : subdomain L for L-scheme
L = {
1: {'wetting' :Lw1,
'nonwetting': Lnw1},
2: {'wetting' :Lw2,
'nonwetting': Lnw2},
3: {'wetting' :Lw3,
'nonwetting': Lnw3},
4: {'wetting' :Lw4,
'nonwetting': Lnw4},
5: {'wetting' :Lw5,
'nonwetting': Lnw5},
}
# interface_num : lambda parameter for the L-scheme on that interface.
# Note that interfaces are numbered starting from 0, because
# adjacent_subdomains is a list and not a dict. Historic fuckup, I know
# We have defined above as interfaces
# # interface_vertices introduces a global numbering of interfaces.
# interface_def_points = [interface13_vertices,
# interface12_vertices,
# interface23_vertices,
# interface24_vertices,
# interface34_vertices,
# interface45_vertices,
# interface15_vertices,]
lambda_param = {
0: {'wetting': lambda13_w,
'nonwetting': lambda13_nw},#
1: {'wetting': lambda12_w,
'nonwetting': lambda12_nw},#
2: {'wetting': lambda23_w,
'nonwetting': lambda23_nw},#
3: {'wetting': lambda24_w,
'nonwetting': lambda24_nw},#
4: {'wetting': lambda34_w,
'nonwetting': lambda34_nw},#
5: {'wetting': lambda45_w,
'nonwetting': lambda45_nw},#
6: {'wetting': lambda15_w,
'nonwetting': lambda15_nw}#
}
# after Lewis, see pdf file
intrinsic_permeability = {
1: 0.01, # sand
2: 0.01, # sand, there is a range
3: 0.01, #10e-2, # clay has a range
4: 0.01, #10e-3
5: 0.01, #10e-2, # clay has a range
6: 0.01, #10e-3
}
# relative permeabilties
rel_perm_definition = {
1: {"wetting": "Spow2",
"nonwetting": "oneMinusSpow2"},
2: {"wetting": "Spow3",
"nonwetting": "oneMinusSpow3"},
3: {"wetting": "Spow3",
"nonwetting": "oneMinusSpow3"},
4: {"wetting": "Spow3",
"nonwetting": "oneMinusSpow3"},
5: {"wetting": "Spow2",
"nonwetting": "oneMinusSpow2"}
}
rel_perm_dict = fts.generate_relative_permeability_dicts(rel_perm_definition)
relative_permeability = rel_perm_dict["ka"]
ka_prime = rel_perm_dict["ka_prime"]
# S-pc relation
Spc_on_subdomains = {
1: {"testSpc": {"index": 1}},
2: {"testSpc": {"index": 2}},
3: {"testSpc": {"index": 2}},
4: {"testSpc": {"index": 2}},
5: {"testSpc": {"index": 1}}
}
Spc = fts.generate_Spc_dicts(Spc_on_subdomains)
S_pc_sym = Spc["symbolic"]
S_pc_sym_prime = Spc["prime_symbolic"]
sat_pressure_relationship = Spc["dolfin"]
#############################################
# Manufacture source expressions with sympy #
#############################################
x, y = sym.symbols('x[0], x[1]') # needed by UFL
t = sym.symbols('t', positive=True)
p_e_sym = {
1: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
'nonwetting': 0*t },
2: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x),
'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
3: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x),
'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
4: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x),
'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
5: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
'nonwetting': 0*t },
}
pc_e_sym = hlp.generate_exact_symbolic_pc(
isRichards=isRichards,
symbolic_pressure=p_e_sym
)
symbols = {"x": x,
"y": y,
"t": t}
# turn above symbolic code into exact solution for dolphin and
# construct the rhs that matches the above exact solution.
exact_solution_example = hlp.generate_exact_solution_expressions(
symbols=symbols,
isRichards=isRichards,
symbolic_pressure=p_e_sym,
symbolic_capillary_pressure=pc_e_sym,
saturation_pressure_relationship=S_pc_sym,
saturation_pressure_relationship_prime=S_pc_sym_prime,
viscosity=viscosity,
porosity=porosity,
intrinsic_permeability=intrinsic_permeability,
relative_permeability=relative_permeability,
relative_permeability_prime=ka_prime,
densities=densities,
gravity_acceleration=gravity_acceleration,
include_gravity=include_gravity,
)
source_expression = exact_solution_example['source']
exact_solution = exact_solution_example['exact_solution']
initial_condition = exact_solution_example['initial_condition']
# BOUNDARY CONDITIONS #########################################################
# Dictionary of dirichlet boundary conditions. If an exact solution case is
# used, use the hlp.generate_exact_DirichletBC() method to generate the
# Dirichlet Boundary conditions from the exact solution.
dirichletBC = hlp.generate_exact_DirichletBC(
isRichards=isRichards,
outer_boundary_def_points=outer_boundary_def_points,
exact_solution=exact_solution
)
# If no exact solution is provided you need to provide a dictionary of boundary
# conditions. See the definiton of hlp.generate_exact_DirichletBC() to see
# the structure.
# LOG FILE OUTPUT #############################################################
# read this file and print it to std out. This way the simulation can produce a
# log file with ./TP-R-layered_soil.py | tee simulation.log
f = open(thisfile, 'r')
print(f.read())
f.close()
# MAIN ########################################################################
if __name__ == '__main__':
# dictionary of simualation parameters to pass to the run function.
# mesh_resolution and starttime are excluded, as they get passed explicitly
# to achieve parallelisation in these parameters in these parameters for
# mesh studies etc.
simulation_parameter = {
"tol": 1E-14,
"debugflag": debugflag,
"max_iter_num": max_iter_num,
"FEM_Lagrange_degree": FEM_Lagrange_degree,
"mesh_study": mesh_study,
"use_case": use_case,
"output_string": output_string,
"subdomain_def_points": subdomain_def_points,
"isRichards": isRichards,
"interface_def_points": interface_def_points,
"outer_boundary_def_points": outer_boundary_def_points,
"adjacent_subdomains": adjacent_subdomains,
# "mesh_resolution": mesh_resolution,
"viscosity": viscosity,
"porosity": porosity,
"L": L,
"lambda_param": lambda_param,
"relative_permeability": relative_permeability,
"intrinsic_permeability": intrinsic_permeability,
"sat_pressure_relationship": sat_pressure_relationship,
# "starttime": starttime,
"number_of_timesteps": number_of_timesteps,
"number_of_timesteps_to_analyse": number_of_timesteps_to_analyse,
"plot_timestep_every": plot_timestep_every,
"timestep_size": timestep_size,
"source_expression": source_expression,
"initial_condition": initial_condition,
"dirichletBC": dirichletBC,
"exact_solution": exact_solution,
"densities": densities,
"include_gravity": include_gravity,
"gravity_acceleration": gravity_acceleration,
"write_to_file": write_to_file,
"analyse_condition": analyse_condition
}
for starttime in starttimes:
for mesh_resolution, solver_tol in resolutions.items():
simulation_parameter.update({"solver_tol": solver_tol})
hlp.info(simulation_parameter["use_case"])
LDDsim = mp.Process(
target=hlp.run_simulation,
args=(
simulation_parameter,
starttime,
mesh_resolution
)
)
LDDsim.start()
LDDsim.join()
# hlp.run_simulation(
# mesh_resolution=mesh_resolution,
# starttime=starttime,
# parameter=simulation_parameter
# )
#!/bin/bash
[ $# -eq 0 ] && { echo "Usage: $0 simulation_file [logfile_name]"; exit 1; }
SIMULATION_FILE=$1
SIMULATION=${SIMULATION_FILE%.py}
LOGFILE_DEFAULT="$SIMULATION.log"
DATE=$(date -I)
LOGFILE=${2:-$DATE-$LOGFILE_DEFAULT}
GREETING="Simulation $SIMULATION is run on $DATE by $USER"
echo $GREETING
echo "running $SIMULATION_FILE | tee $LOGFILE"
./$SIMULATION_FILE | tee $LOGFILE
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment