uniform var name B for magnetic field

Examples/scatter2d/MagneticSpheres.py

@@ -8,9 +8,8 @@ from bornagain import ba_plot as bp, deg, nm, R3
 
 def get_sample():
     # Materials
-    magnetic_field = R3(0, 0, 1e7)
-    material_Particle = ba.RefractiveMaterial("Particle", 2e-05, 4e-07,
-                                              magnetic_field)
+    B = R3(0, 0, 1e7)
+    material_Particle = ba.RefractiveMaterial("Particle", 2e-05, 4e-07, B)
     material_Substrate = ba.RefractiveMaterial("Substrate", 7e-06, 1.8e-07)
     material_Vacuum = ba.RefractiveMaterial("Vacuum", 0, 0)
 

Examples/scatter2d/PolarizedSANS.py

@@ -13,9 +13,8 @@ def get_sample():
     """
 
     # Define materials
-    magnetic_field = R3(0, 1e7, 0)
-    material_Core = ba.RefractiveMaterial("Core", 6e-06, 2e-08,
-                                          magnetic_field)
+    B = R3(0, 1e7, 0)
+    material_Core = ba.RefractiveMaterial("Core", 6e-06, 2e-08, B)
     material_Shell = ba.RefractiveMaterial("Shell", 1e-07, 2e-08)
     material_Solvent = ba.RefractiveMaterial("Solvent", 5e-06, 0)
 

Examples/specular/BasicPolarizedReflectometry.py

@@ -10,15 +10,10 @@ import matplotlib.pyplot as plt
 
 
 def get_sample():
-    """
-    Defines sample and returns it
-    """
-
     # Define materials
     material_Ambient = ba.MaterialBySLD("Ambient", 0, 0)
-    magnetic_field = R3(0, 1e8, 0)
-    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08,
-                                      magnetic_field)
+    B = R3(0, 1e8, 0)
+    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08, B)
     material_Substrate = ba.MaterialBySLD("Substrate", 7e-05, 2e-06)
 
     # Define layers

Examples/specular/PolarizedNoAnalyzer.py

@@ -12,9 +12,8 @@ def get_sample():
     # Define materials
     material_Ambient = ba.MaterialBySLD("Ambient", 0, 0)
     h = 1e8
-    magnetic_field = R3(1/2*h, sqrt(3)/2*h, 0)
-    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08,
-                                      magnetic_field)
+    B = R3(1/2*h, sqrt(3)/2*h, 0)
+    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08, B)
     material_Substrate = ba.MaterialBySLD("Substrate", 7e-05, 2e-06)
 
     # Define layers

Examples/specular/PolarizedNonperfectAnalyzerPolarizer.py

@@ -14,13 +14,12 @@ sldFe = (8.0241e-06, 6.0448e-10)
 sldPd = (4.0099e-6, 1.3019e-09)
 sldMgO = (5.9803e-06, 9.3996e-12)
 
-magnetizationMagnitude = 1.6e6
+Bmag = 1.6e6
 angle = 0
-magnetizationVector = R3(magnetizationMagnitude*numpy.sin(angle*deg),
-                            magnetizationMagnitude*numpy.cos(angle*deg), 0)
+B = R3(Bmag*numpy.sin(angle*deg), Bmag*numpy.cos(angle*deg), 0)
 
 
-def get_sample(*, magnetization=magnetizationVector):
+def get_sample(*, B=B):
     """
     Define sample and returns it
     """
@@ -28,7 +27,7 @@ def get_sample(*, magnetization=magnetizationVector):
     # create materials
     mat_vacuum = ba.MaterialBySLD("Vacuum", 0, 0)
     mat_Pd = ba.MaterialBySLD("Pd", *sldPd)
-    mat_Fe = ba.MaterialBySLD("Fe", *sldFe, magnetizationVector)
+    mat_Fe = ba.MaterialBySLD("Fe", *sldFe, B)
     mat_substrate = ba.MaterialBySLD("MgO", *sldMgO)
 
     # create layers

Examples/specular/PolarizedSpinAsymmetry.py

@@ -25,35 +25,33 @@ scan_size = 1500
 # The SLD of the substrate is kept constant
 sldMao = (5.377e-06, 0)
 
-# constant to convert between magnetization and magnetic SLD
+# constant to convert between B and magnetic SLD
 RhoMconst = 2.910429812376859e-12
 
 ####################################################################
 #                  Create Sample and Simulation                    #
 ####################################################################
 
-
-def get_sample(params):
+def get_sample(P):
     """
     construct the sample with the given parameters
     """
-    magnetizationMagnitude = params["rhoM_Mafo"]*1e-6/RhoMconst
+    BMagnitude = P["rhoM_Mafo"]*1e-6/RhoMconst
     angle = 0
-    magnetizationVector = R3(
-        magnetizationMagnitude*numpy.sin(angle*deg),
-        magnetizationMagnitude*numpy.cos(angle*deg), 0)
+    B = R3(
+        BMagnitude*numpy.sin(angle*deg),
+        BMagnitude*numpy.cos(angle*deg), 0)
 
     mat_vacuum = ba.MaterialBySLD("Vacuum", 0, 0)
-    mat_layer = ba.MaterialBySLD("(Mg,Al,Fe)3O4", params["rho_Mafo"]*1e-6,
-                                 0, magnetizationVector)
+    mat_layer = ba.MaterialBySLD("(Mg,Al,Fe)3O4", P["rho_Mafo"]*1e-6, 0, B)
     mat_substrate = ba.MaterialBySLD("MgAl2O4", *sldMao)
 
     ambient_layer = ba.Layer(mat_vacuum)
-    layer = ba.Layer(mat_layer, params["t_Mafo"]*angstrom)
+    layer = ba.Layer(mat_layer, P["t_Mafo"]*angstrom)
     substrate_layer = ba.Layer(mat_substrate)
 
-    r_Mafo = ba.LayerRoughness(params["r_Mafo"]*angstrom)
-    r_substrate = ba.LayerRoughness(params["r_Mao"]*angstrom)
+    r_Mafo = ba.LayerRoughness(P["r_Mafo"]*angstrom)
+    r_substrate = ba.LayerRoughness(P["r_Mao"]*angstrom)
 
     sample = ba.MultiLayer()
     sample.addLayer(ambient_layer)
@@ -83,13 +81,13 @@ def get_simulation(sample, q_axis, parameters, polarizer_dir,
     return ba.SpecularSimulation(scan, sample)
 
 
-def run_simulation(q_axis, fitParams, *, polarizer_dir, analyzer_dir):
+def run_simulation(q_axis, fitP, *, polarizer_dir, analyzer_dir):
     """
     Run a simulation on the given q-axis, where the sample is
     constructed with the given parameters.
     Vectors for polarization and analyzer need to be provided
     """
-    parameters = dict(fitParams, **fixedParams)
+    parameters = dict(fitP, **fixedP)
 
     sample = get_sample(parameters)
     simulation = get_simulation(sample, q_axis, parameters, polarizer_dir,
@@ -204,7 +202,7 @@ if __name__ == '__main__':
     expdata_pp = load_exp(fname_stem + "pp.tab")
     expdata_mm = load_exp(fname_stem + "mm.tab")
 
-    fixedParams = {
+    fixedP = {
         # parameters from our own fit run
         'q_res': 0.010542945012551425,
         'q_offset': 7.971243487467318e-05,
@@ -215,21 +213,21 @@ if __name__ == '__main__':
         'r_Mafo': 3.7844265311293483
     }
 
-    def run_Simulation_pp(qzs, params):
+    def run_Simulation_pp(qzs, P):
         return run_simulation(qzs,
-                              params,
+                              P,
                               polarizer_dir=R3(0, 1, 0),
                               analyzer_dir=R3(0, 1, 0))
 
-    def run_Simulation_mm(qzs, params):
+    def run_Simulation_mm(qzs, P):
         return run_simulation(qzs,
-                              params,
+                              P,
                               polarizer_dir=R3(0, -1, 0),
                               analyzer_dir=R3(0, -1, 0))
 
     qzs = numpy.linspace(qmin, qmax, scan_size)
-    q_pp, r_pp = qr(run_Simulation_pp(qzs, fixedParams))
-    q_mm, r_mm = qr(run_Simulation_mm(qzs, fixedParams))
+    q_pp, r_pp = qr(run_Simulation_pp(qzs, fixedP))
+    q_mm, r_mm = qr(run_Simulation_mm(qzs, fixedP))
 
     data_pp = filterData(expdata_pp, qmin, qmax)
     data_mm = filterData(expdata_mm, qmin, qmax)

Examples/specular/PolarizedSpinFlip.py

@@ -13,9 +13,8 @@ def get_sample():
     # Define materials
     material_Ambient = ba.MaterialBySLD("Ambient", 0, 0)
     h = 1e8
-    magnetic_field = R3(1/2*h, sqrt(3)/2*h, 0)
-    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08,
-                                      magnetic_field)
+    B = R3(1/2*h, sqrt(3)/2*h, 0)
+    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08, B)
     material_Substrate = ba.MaterialBySLD("Substrate", 7e-05, 2e-06)
 
     # Define layers