m

xppbe/Mesh/Mesh.py

@@ -277,6 +277,8 @@ def create_mesh_obj(self):
         if 'D2' in self.losses_names or 'R2' in self.losses_names:
             sphere_min, sphere_max = np.min(self.sphere_mesh.vertices, axis=0), np.max(self.sphere_mesh.vertices, axis=0)
             self.scale_2 = [sphere_min.tolist(), sphere_max.tolist()]
+        else:
+            self.scale_2 = self.scale_1
 
         if self.save_points:
             X_plot = dict()

xppbe/Model/PDE_Model.py

@@ -307,19 +307,50 @@ def directional_gradient(self,mesh,model,X,n_v,flag,value='phi'):
     def get_charges(self):
         self.pqr_path = os.path.join(self.molecule_path,self.molecule+'.pqr')
         self.q_list = get_charges_list(self.pqr_path)
-        self.scale_q_factor = min(self.q_list, key=lambda q_obj: np.abs(q_obj.q)).q
+        #self.scale_q_factor = min(self.q_list, key=lambda q_obj: np.abs(q_obj.q)).q
+        scale_min_value, scale_max_value = 0.,0.
 
         n = len(self.q_list)
         self.qs = np.zeros(n)
         self.x_qs = np.zeros((n,3))
         for i,q in enumerate(self.q_list):
             self.qs[i] = q.q
             self.x_qs[i,:] = q.x_q
+
+            value = self.analytic_Born_Ion(0.0, R=self.q_list[i].r_q, index_q=i)
+            if value > scale_max_value:
+                scale_max_value = value
+            if value < scale_min_value:
+                scale_min_value = value
+        self.scale_phi_1 = [scale_min_value,scale_max_value]
+        self.scale_phi_2 = [scale_min_value,scale_max_value]
 
         self.total_charge = tf.constant(np.sum(self.qs), dtype=self.DTYPE)
         self.qs = tf.constant(self.qs, dtype=self.DTYPE)
         self.x_qs = tf.constant(self.x_qs, dtype=self.DTYPE)
 
+        scale_min_value_1, scale_max_value_1 = 0.,0.
+        scale_min_value_2, scale_max_value_2 = 0.,0.
+        for i,q in enumerate(self.q_list):
+
+            phi = self.analytic_Born_Ion(0.0, R=self.q_list[i].r_q, index_q=i)
+            if phi > scale_max_value_1:
+                scale_max_value_1 = phi
+            if phi < scale_min_value_1:
+                scale_min_value_1 = phi
+
+            if self.PDE_out.field == 'phi':
+                phi += self.G(tf.constant([[self.q_list[i].r_q,0,0]],dtype=self.DTYPE))
+
+            if phi > scale_max_value_2:
+                scale_max_value_2 = phi
+            if phi < scale_min_value_2:
+                scale_min_value_2 = phi
+
+        self.scale_phi_1 = (scale_min_value_1,scale_max_value_1)
+        self.scale_phi_2 = (scale_min_value_2,scale_max_value_2)
+
+
     def get_integral_operators(self):
         if self.bempp == None:
             import bempp.api

xppbe/Model/Solutions_utils.py

@@ -169,13 +169,13 @@ def dG_Y(self,X,Xp,N):
         return dg_dn
 
 
-    def analytic_Born_Ion(self,r, R=None):
+    def analytic_Born_Ion(self,r, R=None, index_q=0):
         if R is None:
             R = self.mesh.R_mol
         epsilon_1 = self.epsilon_1
         epsilon_2 = self.epsilon_2
         kappa = self.kappa
-        q = self.q_list[0].q
+        q = self.q_list[index_q].q
 
         f_IN = lambda r: (q/(4*self.pi)) * ( - 1/(epsilon_1*R) + 1/(epsilon_2*(1+kappa*R)*R) )
         f_OUT = lambda r: (q/(4*self.pi)) * (np.exp(-kappa*(r-R))/(epsilon_2*(1+kappa*R)*r) - 1/(epsilon_1*r))
@@ -244,8 +244,7 @@ def Spherical_Harmonics(self, x, flag, R=None, N=20):
 
             PHI[K] = np.real(phi)
 
-        return PHI
-
+        return tf.constant(PHI, dtype=self.DTYPE)
 
     @staticmethod
     def get_K(x, n):

xppbe/NN/NeuralNet.py

@@ -45,6 +45,8 @@ def build_Net(self):
 
 class NeuralNet(tf.keras.Model):
 
+    DTYPE = 'float32'
+
     def __init__(self, 
                  input_shape=(None, 3),
                  output_dim=1,
@@ -60,8 +62,9 @@ def __init__(self,
                  fourier_sigma=1,
                  weight_factorization=False,
                  scale_input=True,
-                 scale_NN=1.0,
-                 scale=([-1.,-1.,-1.],[1.,1.,1.]),
+                 scale_output=False,
+                 scale_input_s=([-1.,-1.,-1.],[1.,1.,1.]),
+                 scale_output_s=(-1.,1.),
                  **kwargs):
         super().__init__(**kwargs)
 
@@ -80,11 +83,15 @@ def __init__(self,
         self.num_fourier_features = num_fourier_features
         self.fourier_sigma = fourier_sigma
         self.weight_factorization = weight_factorization
-
+ 
         self.scale_input = scale_input
-        self.scale_NN = scale_NN
-        self.lb = tf.constant(scale[0])
-        self.ub = tf.constant(scale[1])
+        self.input_lb = tf.constant(scale_input_s[0], dtype=self.DTYPE)
+        self.input_ub = tf.constant(scale_input_s[1], dtype=self.DTYPE)
+
+        self.scale_output = scale_output
+        self.output_lb = tf.constant(scale_output_s[0], dtype=self.DTYPE)
+        self.output_ub = tf.constant(scale_output_s[1], dtype=self.DTYPE)
+
 
         if not self.weight_factorization:
             self.Dense_Layer = tf.keras.layers.Dense
@@ -93,8 +100,8 @@ def __init__(self,
 
         # Scale layer
         if self.scale_input:
-            self.scale = tf.keras.layers.Lambda(
-                            lambda x: 2.0 * (x - self.lb) / (self.ub - self.lb) - 1.0, 
+            self.scale_in = tf.keras.layers.Lambda(
+                            lambda x: 2.0 * (x - self.input_lb) / (self.input_ub - self.input_lb) - 1.0, 
                             name=f'scale_layer')
 
         # Fourier feature layer
@@ -121,14 +128,14 @@ def __init__(self,
         # Output layer
         self.out = tf.keras.layers.Dense(output_dim,
                                activation=None,
-                               use_bias=False,
                                name=f'output_layer')
 
         # Scale output layer
-        self.scale_out = tf.keras.layers.Lambda(
-                            lambda x: x*self.scale_NN, 
-                            name=f'scale_output_layer')
-
+        if self.scale_output:
+            self.scale_out = tf.keras.layers.Lambda(
+                                lambda x: (x+1.0)/2.0 * (self.output_ub-self.output_lb)+self.output_lb, 
+                                name=f'scale_output_layer')
+
 
     def create_FCNN(self):
         self.hidden_layers = list()
@@ -198,12 +205,14 @@ def build_Net(self):
 
     def call(self, X):
         if self.scale_input:
-            X = self.scale(X)
+            X = self.scale_in(X)
         if self.use_fourier_features:
             X = self.fourier_features(X) 
         X = self.call_architecture(X)
         X = self.out(X)
-        return self.scale_out(X)
+        if self.scale_output:
+            X = self.scale_out(X)
+        return X
 
     def call_FCNN(self, X):
         for layer in self.hidden_layers:

xppbe/Simulation.py

@@ -127,19 +127,18 @@ def adapt_model(self):
             from xppbe.NN.NeuralNet import PINN_2Dom_NeuralNet as NeuralNet
         elif self.num_networks == 1 or self.pinns_method=='DBM':
             from xppbe.NN.NeuralNet import PINN_1Dom_NeuralNet as NeuralNet     
-
+ 
 
         if self.starting_point == 'new':
 
-            self.hyperparameters_in['scale'] = self.PINN_solver.mesh.scale_1
-            if self.pinns_method!='DBM':
-                self.hyperparameters_out['scale'] = self.PINN_solver.mesh.scale_2
-            else: 
-                self.hyperparameters_out['scale'] = self.PINN_solver.mesh.scale_1
-
-            if self.scale_NN_q:
-                self.hyperparameters_in['scale_NN'] = self.PBE_model.scale_q_factor
-                self.hyperparameters_out['scale_NN'] = self.PBE_model.scale_q_factor 
+            self.hyperparameters_in['scale_input_s'] = self.PINN_solver.mesh.scale_1
+            self.hyperparameters_out['scale_input_s'] = self.PINN_solver.mesh.scale_2
+
+            if self.PBE_model.PDE_in.field == 'phi':
+                 self.hyperparameters_in['scale_output'] = False
+
+            self.hyperparameters_in['scale_output_s'] = self.PBE_model.scale_phi_1
+            self.hyperparameters_out['scale_output_s'] = self.PBE_model.scale_phi_2
 
             self.PINN_solver.create_NeuralNet(NeuralNet,[self.hyperparameters_in,self.hyperparameters_out])
 

xppbe/Simulation.yaml

@@ -69,6 +69,8 @@ hyperparameters_in:
     architecture_Net: FCNN
     fourier_features: true
     weight_factorization: false
+    scale_input: True
+    scale_output: False
 
 hyperparameters_out:
     input_shape: [null, 3]
@@ -80,9 +82,8 @@ hyperparameters_out:
     architecture_Net: FCNN
     fourier_features: true
     weight_factorization: false
-
-# Scale charges
-scale_NN_q: false
+    scale_input: True
+    scale_output: False
 
 # Optimizer properties
 optimizer: Adam