def update_sigma(the_field_sigma): compute_J=nfem.prematrix_applicator(prematrix_J, mwe_mid=the_field_sigma) laplace_solver=nfem.laplace_solver(prematrix_laplace, dirichlet_bcs=[(-1,1,laplace_dbc)], mwe_mid=the_field_sigma) # field_phi = laplace_solver(cofield_drho_by_dt, dbc_values=laplace_dbc_values) field_J = nfem.cofield_to_field(compute_J(field_phi)) # XXX NOTE: we should be able to make an applicator that does the # cofield_to_field conversion automatically! # # # Next, let us compute the new condictivity by site-wise operation on # field_J. We just overwrite field_sigma: # recompute_conductivity=nfem.site_wise_applicator(parameter_names=["H_x","H_y","sigma0","alpha"], # all the names of extra parameters code=code_recompute_conductivity, fields=[the_field_sigma,field_J] ) # # recompute_conductivity([h_x,h_y,sigma0,alpha]) return the_field_sigma
def save_field(field, fieldname, filename): ccode = ( ''' #line 19 "save_field.py" static FILE *f = (FILE *) NULL; if ( close_file > 0.0 ) { if ( f != (FILE *) NULL) { (void) fclose(f); f = (FILE *) NULL; } } else { if ( f == (FILE *) NULL ) f = fopen("''' + filename + """", "w"); if ( f != (FILE *) NULL ) { if ( have_""" + fieldname + """ ) { double c[3] = {0.0, 0.0, 0.0}; int i; for(i=0; i<((int) dim); i++) c[i] = COORDS(i); fprintf(f, "%g %f %f %f %g %g %g\\n", time, c[0], c[1], c[2], """ + fieldname + """(0), """ + fieldname + """(1), """ + fieldname + """(2)); } } } """ ) dim = float(field_dim(field)) mwe = ocaml.get_mwe(field) fn = nfem.site_wise_applicator(["close_file", "time", "dim"], ccode, field_mwes=[mwe]) def saver(close=False, time=0.0): if close: fn([1.0, float(time), dim], fields=[field]) else: fn([-1.0, float(time), dim], fields=[field]) return saver
def surface_interaction(m_h_list, couplings): """This function is used to calculate the exchange interactions between magnetisations defined at the same sites in the mesh.""" mwes = [] fields = [] i = 1 for m_h_couple in m_h_list: m, h = m_h_couple m_new_name = "m%d" % i h_new_name = "h%d" % i i += 1 mwe_m = ocaml.get_mwe(m) mwe_mn = nfem.mwe_sibling(mwe_m, m_new_name, "renamed_m", [("m", m_new_name)]) mn = nfem.field_alias(m, mwe_mn) mwe_h = ocaml.get_mwe(h) mwe_hn = nfem.mwe_sibling(mwe_h, h_new_name, "renamed_h", [("h_total", h_new_name)]) hn = nfem.field_alias(h, mwe_hn) fields.append(mn) fields.append(hn) mwes.append(mwe_mn) mwes.append(mwe_hn) ccode = ccode_surface_interaction for ac in couplings: i1, i2, m_sat1, m_sat2, ec = ac # ec is the exchange coupling constant ccode += "SURF_INTERACTION(m%d, %f, h%d, m%d, %f, h%d, %f)\n" % \ (i1, m_sat1, i1, i2, m_sat2, i2, ec) original_fn = nfem.site_wise_applicator([], ccode, field_mwes=mwes) def fn(): original_fn([], fields=fields) return fn
def surface_interaction(m_h_list, couplings): """This function is used to calculate the exchange interactions between magnetisations defined at the same sites in the mesh.""" mwes = [] fields = [] i = 1 for m_h_couple in m_h_list: m, h = m_h_couple m_new_name = "m%d" % i h_new_name = "h%d" % i i += 1 mwe_m = ocaml.get_mwe(m) mwe_mn = nfem.mwe_sibling(mwe_m, m_new_name, "renamed_m", [("m", m_new_name)]) mn = nfem.field_alias(m, mwe_mn) mwe_h = ocaml.get_mwe(h) mwe_hn = nfem.mwe_sibling(mwe_h, h_new_name, "renamed_h", [("h_total", h_new_name)]) hn = nfem.field_alias(h, mwe_hn) fields.append( mn ) fields.append( hn ) mwes.append( mwe_mn ) mwes.append( mwe_hn ) ccode = ccode_surface_interaction for ac in couplings: i1, i2, m_sat1, m_sat2, ec = ac # ec is the exchange coupling constant ccode += "SURF_INTERACTION(m%d, %f, h%d, m%d, %f, h%d, %f)\n" % \ (i1, m_sat1, i1, i2, m_sat2, i2, ec) original_fn = nfem.site_wise_applicator([], ccode, field_mwes=mwes) def fn(): original_fn([], fields=fields) return fn
def setup(self): '''This function should be called after the method 'set' to setup the simulation (create the fields, the operators and so on)''' # Should not do initializizations more than once if self.is_ready: return self.damping = self.features["damping"] self.gamma_G = self.features["gamma_G"] self.gamma_LL = self.features["gamma_LL"] self.absolute_step_error = self.features["absolute_step_error"] self.relative_step_error = self.features["relative_step_error"] self.step_headroom = self.features["step_headroom"] self.stopping_time = self.features["stopping_time"] self.stopping_dm_dt = self.features["stopping_dm_dt"] self.max_iterations = self.features["max_iterations"] self.max_rejections = self.features["max_rejections"] self.initial_dt = self.features["initial_dt"] self.max_dt_ratio = self.features["max_dt_ratio"] self.initial_time = self.features["initial_time"] self.time = 0.0 MumagCore.setup(self) # self.llg_gamma_LL == None if llg_gamma_G is given by the user if self.gamma_LL == None: self.gamma_LL = self.gamma_G / (1.0 + self.damping**2) self.new_field("old_m", indices=[3], initial_values=self.initial_mag) self.new_field("dm_dt", indices=[3]) self.new_field("old_dm_dt", indices=[3]) self.new_field("delta_t", indices=[]) # Just some shorthands for what follows mwe_m = self.mwes["m"] field_m = self.fields["m"] # The auxiliary arguments passed from python to C args_names = [ "time", "dt", "old_max_norm_dm_dt", "llg_damping", "llg_gamma_LL", "absolute_step_error", "relative_step_error", "step_headroom", "m_sat" ] # Create the C-functions which perform the different parts # of the computation # The fields which will be passed to 'step_make' and 'step_check' some_names = [ "m", "old_m", "dm_dt", "old_dm_dt", "delta_t", "h_ext", "h_total", "h_demag", "h_exch" ] some_mwes = self.mwe_list(some_names) some_fields = self.field_list(some_names) # Called to execute the euler step (calculate the new m and the # value of old_norm_dm_dt needed for the computation of the error) c_step_make = nfem.site_wise_applicator(args_names, ccode_step_make, field_mwes=some_mwes) def step_make(time, dt): self.old_max_norm_dm_dt = 0.0 aux_arg_list = [ time, dt, self.old_max_norm_dm_dt, self.damping, self.gamma_LL, self.absolute_step_error, self.relative_step_error, self.step_headroom, self.m_sat ] modified_args = c_step_make(aux_arg_list, fields=some_fields) self.old_max_norm_dm_dt = modified_args[2] #----------------------End of definition of the function step_make self.step_make = step_make c_step_check = nfem.site_wise_applicator(args_names, ccode_step_check, field_mwes=some_mwes) def step_check(time, dt): aux_arg_list = [ time, dt, self.old_max_norm_dm_dt, self.damping, self.gamma_LL, self.absolute_step_error, self.relative_step_error, self.step_headroom, self.m_sat ] c_step_check(aux_arg_list, fields=some_fields) #----------------------End of definition of the function step_check self.step_check = step_check self.c_calculate_next_dt = nfem.site_wise_applicator( ["accepted_step", "previous_dt"], ccode_calculate_next_dt, field_mwes=[self.mwes["delta_t"]]) self.step_calculate_h_total = self.calculate_h_total self.is_ready = True self.next_stage(time=self.initial_time)
else { double j=drho_by_dt; if(j>0)total_bad_current_plus+=j; else total_bad_current_minus+=j; } """ _cofield_div_J=nfem.make_cofield(mwe_drho_by_dt) _accumulate_J_total=nfem.site_wise_applicator(parameter_names=["total_current_up", "total_current_down", "total_bad_current_plus", "total_bad_current_minus" ], code=code_integrate_div_J, position_name="coords", cofields=[_cofield_div_J]) def compute_total_current(the_field_sigma): laplace_solver=nfem.laplace_solver(prematrix_laplace, dirichlet_bcs=[(-1,1,laplace_dbc)], mwe_mid=the_field_sigma) compute_div_J=nfem.prematrix_applicator(prematrix_laplace, mwe_mid=the_field_sigma) field_phi=laplace_solver(cofield_drho_by_dt, dbc_values=laplace_dbc_values) print "OK 1 - field_phi!\n" sys.stdout.flush() compute_div_J(field_phi, target=_cofield_div_J)
def setup(self): '''This function should be called after the method 'set' to setup the simulation (create the fields, the operators and so on)''' # Should not do initializizations more than once if self.is_ready: return self.damping = self.features["damping"] self.gamma_G = self.features["gamma_G"] self.gamma_LL = self.features["gamma_LL"] self.absolute_step_error = self.features["absolute_step_error"] self.relative_step_error = self.features["relative_step_error"] self.step_headroom = self.features["step_headroom"] self.stopping_time = self.features["stopping_time"] self.stopping_dm_dt = self.features["stopping_dm_dt"] self.max_iterations = self.features["max_iterations"] self.max_rejections = self.features["max_rejections"] self.initial_dt = self.features["initial_dt"] self.max_dt_ratio = self.features["max_dt_ratio"] self.initial_time = self.features["initial_time"] self.time = 0.0 MumagCore.setup(self) # self.llg_gamma_LL == None if llg_gamma_G is given by the user if self.gamma_LL == None: self.gamma_LL = self.gamma_G/(1.0+self.damping**2) self.new_field("old_m", indices=[3], initial_values=self.initial_mag) self.new_field("dm_dt", indices=[3]) self.new_field("old_dm_dt", indices=[3]) self.new_field("delta_t", indices=[]) # Just some shorthands for what follows mwe_m = self.mwes["m"] field_m = self.fields["m"] # The auxiliary arguments passed from python to C args_names = ["time", "dt", "old_max_norm_dm_dt", "llg_damping", "llg_gamma_LL", "absolute_step_error", "relative_step_error", "step_headroom", "m_sat"] # Create the C-functions which perform the different parts # of the computation # The fields which will be passed to 'step_make' and 'step_check' some_names = ["m", "old_m", "dm_dt", "old_dm_dt", "delta_t", "h_ext", "h_total", "h_demag", "h_exch"] some_mwes = self.mwe_list(some_names) some_fields = self.field_list(some_names) # Called to execute the euler step (calculate the new m and the # value of old_norm_dm_dt needed for the computation of the error) c_step_make = nfem.site_wise_applicator(args_names, ccode_step_make, field_mwes=some_mwes) def step_make(time, dt): self.old_max_norm_dm_dt = 0.0 aux_arg_list = [time, dt, self.old_max_norm_dm_dt, self.damping, self.gamma_LL, self.absolute_step_error, self.relative_step_error, self.step_headroom, self.m_sat] modified_args = c_step_make(aux_arg_list, fields=some_fields) self.old_max_norm_dm_dt = modified_args[2] #----------------------End of definition of the function step_make self.step_make = step_make c_step_check = nfem.site_wise_applicator(args_names, ccode_step_check, field_mwes=some_mwes) def step_check(time, dt): aux_arg_list = [time, dt, self.old_max_norm_dm_dt, self.damping, self.gamma_LL, self.absolute_step_error, self.relative_step_error, self.step_headroom, self.m_sat] c_step_check(aux_arg_list, fields=some_fields) #----------------------End of definition of the function step_check self.step_check = step_check self.c_calculate_next_dt = nfem.site_wise_applicator( ["accepted_step", "previous_dt"], ccode_calculate_next_dt, field_mwes=[self.mwes["delta_t"]]) self.step_calculate_h_total = self.calculate_h_total self.is_ready = True self.next_stage(time=self.initial_time)
nfem.plot_scalar_field(nfem.cofield_to_field(cofield2d_div_M), "rho_M","/tmp/plot-rho-M.ps", plot_edges=False, color_scheme=[(-2.0,[0.1,0.1,1.0]), (0.0,[0.1,1.0,0.1]), (2.0,[1.0,0.1,0.1])]) # End DDDDDD # we still have to correct the Z-field component. For now, we do this # with a site-wise applicator... adjust_H_z_2d=nfem.site_wise_applicator(parameter_names=[], # all the names of extra parameters code="H(2)=-M(2);", field_mwes=[mwe2d_M,mwe2d_H] ) adjust_H_z_2d([],fields=[field2d_M0,field2d_H]) # nfem.field_print_contents(field2d_H) # DDD print "*** The 2.5-dimensional result ***" for i in range(0,76): pos=[-3.8+i*0.1,0.0] print "Position ",pos," H: ",nfem.probe_field(field2d_H,pos) # === The 3d computation === nfem.set_default_mesh(mesh_3d)
code_recompute_conductivity=""" double len2_J, sprod_HJ, cos2; double len2_H=H_x*H_x+H_y*H_y; len2_J=J(0)*J(0)+J(1)*J(1); sprod_HJ=H_x*J(0)+H_y*J(1); cos2=(fabs(len2_J)<1e-8)?0.0:(sprod_HJ*sprod_HJ/(len2_H*len2_J)); sigma = sigma0 + alpha * cos2; /* printf(\"cos2=%f sigma = %8.6f\\n \",cos2, sigma); */ """ recompute_conductivity=nfem.site_wise_applicator(parameter_names=["H_x","H_y","sigma0","alpha"], # all the names of extra parameters code=code_recompute_conductivity, field_mwes=[mwe_sigma,mwe_J] ) # computing the total current through the sample: code_integrate_div_J=""" if(coords(1)>2.45) { total_current_up+=drho_by_dt; } else if(coords(1)<-2.45) { total_current_down+=drho_by_dt; } else
def setup(self): '''This function should be called after the method 'set' to setup the simulation (create the fields, the operators and so on)''' # Should not do initializizations more than once if self.is_ready: return mwe_m, field_m = self.new_mwe_and_field("m", [3], initial_values=self.initial_mag) mwe_h_total, field_h_total = self.new_mwe_and_field("h_total", [3]) if self.features["include_demag"]: self.new_field("h_demag", indices=[3]) if self.features["include_exchange"]: self.new_field("h_exch", indices=[3]) if self.features["external_field"]: h0 = self.features["external_field"] self.new_field("h_ext", indices=[3], initial_values=h0) # The demag field if self.features["include_demag"]: if self.mesh.dim != 3: raise "Sorry, the demag-calculation is implemented only for 3-D space." mwe_h_demag = self.mwes["h_demag"] field_h_demag = self.fields["h_demag"] mwe_scalar = self.new_mwe("scalar") mwe_rho_m = nfem.mwe_sibling(mwe_scalar, "mwe_rho_m", "renamed_scalar", [("scalar", "rho_m")]) mwe_phi_m = nfem.mwe_sibling(mwe_scalar, "mwe_phi_m", "renamed_scalar", [("scalar", "phi_m")]) field_div_m = nfem.make_field(mwe_rho_m) field_phi_m = nfem.make_field(mwe_phi_m) diffop_div_m_str = "%f <rho_m||d/dxj m(j)>, j:3" % self.m_sat print diffop_div_m_str compute_div_m = \ nfem.diffop_applicator(diffop_div_m_str, mwe_rho_m, mwe_m, interface_coeffs=[(-2,-2,1.0)], petsc_name="mumag_div_m") prematrix_laplace = \ nfem.prematrix("-<d/dxj rho_m||d/dxj phi_m>, j:3", mwe_rho_m, mwe_phi_m) solve_bem = \ nfem.laplace_solver_bem(prematrix_laplace, inside_regions=self.where) compute_grad_phi = \ nfem.diffop_applicator("<h_demag(j)||d/dxj phi_m>, j:3", mwe_h_demag, mwe_phi_m, result="field") cofield_div_m = compute_div_m(self.fields["m"]) solve_bem(cofield_div_m, target=field_phi_m) compute_grad_phi(field_phi_m, target=field_h_demag) def calculate_h_demag(): compute_div_m(self.fields["m"], target=cofield_div_m) solve_bem(cofield_div_m, target=field_phi_m) compute_grad_phi(field_phi_m, target=field_h_demag) self.calculate_h_demag = calculate_h_demag # Now we add the exchange and demag fields if needed if self.features["include_exchange"]: if not self.features["exchange_coupling"]: raise "You want to include exchange interaction, " + \ "but you did not specify the exchange coupling constant!" ec = self.features["exchange_coupling"] if ec < 0.0: raise "Error: you specified a negative exchange coupling constant." mwe_h_exch = self.mwes["h_exch"] field_h_exch = self.fields["h_exch"] exch_factor = -2.0*ec/self.m_sat_mu0 op_str = "%f <d/dxi h_exch(j) || d/dxi m(j)>, i:%d, j:3" % (exch_factor, self.mesh.dim) op_h_exch = nfem.diffop(op_str) p = nfem.prematrix(op_h_exch, mwe_h_exch, mwe_m, ignore_jumps=True) compute_h_exch = nfem.prematrix_applicator(p) h_exch_cofield = compute_h_exch(field_m) nfem.cofield_to_field(h_exch_cofield, target=field_h_exch) def calculate_h_exch(): compute_h_exch(field_m, target=h_exch_cofield) nfem.cofield_to_field(h_exch_cofield, target=field_h_exch) self.calculate_h_exch = calculate_h_exch # Create the C-functions which performs the different parts # of the computation some_names = ["m", "h_total"] some_mwes = self.mwe_list(some_names) some_fields = self.field_list(some_names) if self.uniaxial_anis: args = ["m_sat_mu0", "axis_x", "axis_y", "axis_z", "k1", "k2"] c_uniaxial = nfem.site_wise_applicator(args, ccode_uniaxial, field_mwes=some_mwes) def calculate_uniaxial_anis(): for ua in self.uniaxial_anis: axis, k1, k2 = ua axis_x, axis_y, axis_z = axis args_values = [self.m_sat_mu0, axis_x, axis_y, axis_z, k1, k2] c_uniaxial(args_values, fields=some_fields) self.calculate_uniaxial_anis = calculate_uniaxial_anis if self.cubic_anis: args = ["m_sat_mu0", "axis1_x", "axis1_y", "axis1_z", "axis2_x", "axis2_y", "axis2_z", "k1", "k2", "k3"] c_cubic = nfem.site_wise_applicator(args, ccode_cubic, field_mwes=some_mwes) def calculate_cubic_anis(): for ca in self.cubic_anis: axis1, axis2, k1, k2, k3 = ca axis1_x, axis1_y, axis1_z = axis1 axis2_x, axis2_y, axis2_z = axis2 args_values = [self.m_sat_mu0, axis1_x, axis1_y, axis1_z, axis2_x, axis2_y, axis2_z, k1, k2, k3] c_cubic(args_values, fields=some_fields) self.calculate_cubic_anis = calculate_cubic_anis more_names = ["h_total", "h_ext", "h_demag", "h_exch"] more_mwes = self.mwe_list(more_names) more_fields = self.field_list(more_names) add_fields = nfem.site_wise_applicator([], ccode_add_fields, field_mwes=more_mwes) def add_ext_demag_exch(): add_fields([], fields=more_fields) self.add_ext_demag_exch = add_ext_demag_exch if self.features["calculate_energy"]: swa_calculate_energy = \ nfem.site_wise_applicator(["energy"], ccode_calculate_energy, field_mwes=[mwe_m],cofield_mwes=[mwe_h_total]) cofield_h_total = nfem.field_to_cofield(field_h_total) def calculate_energy(): nfem.field_to_cofield(field_h_total, target=cofield_h_total) energy = swa_calculate_energy([0.0], fields=[field_m], cofields=[cofield_h_total]) return -self.m_sat_mu0*energy[0] self.__calculate_energy = calculate_energy self.is_ready = True
def setup(self): '''This function should be called after the method 'set' to setup the simulation (create the fields, the operators and so on)''' # Should not do initializizations more than once if self.is_ready: return mwe_m, field_m = self.new_mwe_and_field( "m", [3], initial_values=self.initial_mag) mwe_h_total, field_h_total = self.new_mwe_and_field("h_total", [3]) if self.features["include_demag"]: self.new_field("h_demag", indices=[3]) if self.features["include_exchange"]: self.new_field("h_exch", indices=[3]) if self.features["external_field"]: h0 = self.features["external_field"] self.new_field("h_ext", indices=[3], initial_values=h0) # The demag field if self.features["include_demag"]: if self.mesh.dim != 3: raise "Sorry, the demag-calculation is implemented only for 3-D space." mwe_h_demag = self.mwes["h_demag"] field_h_demag = self.fields["h_demag"] mwe_scalar = self.new_mwe("scalar") mwe_rho_m = nfem.mwe_sibling(mwe_scalar, "mwe_rho_m", "renamed_scalar", [("scalar", "rho_m")]) mwe_phi_m = nfem.mwe_sibling(mwe_scalar, "mwe_phi_m", "renamed_scalar", [("scalar", "phi_m")]) field_div_m = nfem.make_field(mwe_rho_m) field_phi_m = nfem.make_field(mwe_phi_m) diffop_div_m_str = "%f <rho_m||d/dxj m(j)>, j:3" % self.m_sat print diffop_div_m_str compute_div_m = \ nfem.diffop_applicator(diffop_div_m_str, mwe_rho_m, mwe_m, interface_coeffs=[(-2,-2,1.0)], petsc_name="mumag_div_m") prematrix_laplace = \ nfem.prematrix("-<d/dxj rho_m||d/dxj phi_m>, j:3", mwe_rho_m, mwe_phi_m) solve_bem = \ nfem.laplace_solver_bem(prematrix_laplace, inside_regions=self.where) compute_grad_phi = \ nfem.diffop_applicator("<h_demag(j)||d/dxj phi_m>, j:3", mwe_h_demag, mwe_phi_m, result="field") cofield_div_m = compute_div_m(self.fields["m"]) solve_bem(cofield_div_m, target=field_phi_m) compute_grad_phi(field_phi_m, target=field_h_demag) def calculate_h_demag(): compute_div_m(self.fields["m"], target=cofield_div_m) solve_bem(cofield_div_m, target=field_phi_m) compute_grad_phi(field_phi_m, target=field_h_demag) self.calculate_h_demag = calculate_h_demag # Now we add the exchange and demag fields if needed if self.features["include_exchange"]: if not self.features["exchange_coupling"]: raise "You want to include exchange interaction, " + \ "but you did not specify the exchange coupling constant!" ec = self.features["exchange_coupling"] if ec < 0.0: raise "Error: you specified a negative exchange coupling constant." mwe_h_exch = self.mwes["h_exch"] field_h_exch = self.fields["h_exch"] exch_factor = -2.0 * ec / self.m_sat_mu0 op_str = "%f <d/dxi h_exch(j) || d/dxi m(j)>, i:%d, j:3" % ( exch_factor, self.mesh.dim) op_h_exch = nfem.diffop(op_str) p = nfem.prematrix(op_h_exch, mwe_h_exch, mwe_m, ignore_jumps=True) compute_h_exch = nfem.prematrix_applicator(p) h_exch_cofield = compute_h_exch(field_m) nfem.cofield_to_field(h_exch_cofield, target=field_h_exch) def calculate_h_exch(): compute_h_exch(field_m, target=h_exch_cofield) nfem.cofield_to_field(h_exch_cofield, target=field_h_exch) self.calculate_h_exch = calculate_h_exch # Create the C-functions which performs the different parts # of the computation some_names = ["m", "h_total"] some_mwes = self.mwe_list(some_names) some_fields = self.field_list(some_names) if self.uniaxial_anis: args = ["m_sat_mu0", "axis_x", "axis_y", "axis_z", "k1", "k2"] c_uniaxial = nfem.site_wise_applicator(args, ccode_uniaxial, field_mwes=some_mwes) def calculate_uniaxial_anis(): for ua in self.uniaxial_anis: axis, k1, k2 = ua axis_x, axis_y, axis_z = axis args_values = [ self.m_sat_mu0, axis_x, axis_y, axis_z, k1, k2 ] c_uniaxial(args_values, fields=some_fields) self.calculate_uniaxial_anis = calculate_uniaxial_anis if self.cubic_anis: args = [ "m_sat_mu0", "axis1_x", "axis1_y", "axis1_z", "axis2_x", "axis2_y", "axis2_z", "k1", "k2", "k3" ] c_cubic = nfem.site_wise_applicator(args, ccode_cubic, field_mwes=some_mwes) def calculate_cubic_anis(): for ca in self.cubic_anis: axis1, axis2, k1, k2, k3 = ca axis1_x, axis1_y, axis1_z = axis1 axis2_x, axis2_y, axis2_z = axis2 args_values = [ self.m_sat_mu0, axis1_x, axis1_y, axis1_z, axis2_x, axis2_y, axis2_z, k1, k2, k3 ] c_cubic(args_values, fields=some_fields) self.calculate_cubic_anis = calculate_cubic_anis more_names = ["h_total", "h_ext", "h_demag", "h_exch"] more_mwes = self.mwe_list(more_names) more_fields = self.field_list(more_names) add_fields = nfem.site_wise_applicator([], ccode_add_fields, field_mwes=more_mwes) def add_ext_demag_exch(): add_fields([], fields=more_fields) self.add_ext_demag_exch = add_ext_demag_exch if self.features["calculate_energy"]: swa_calculate_energy = \ nfem.site_wise_applicator(["energy"], ccode_calculate_energy, field_mwes=[mwe_m],cofield_mwes=[mwe_h_total]) cofield_h_total = nfem.field_to_cofield(field_h_total) def calculate_energy(): nfem.field_to_cofield(field_h_total, target=cofield_h_total) energy = swa_calculate_energy([0.0], fields=[field_m], cofields=[cofield_h_total]) return -self.m_sat_mu0 * energy[0] self.__calculate_energy = calculate_energy self.is_ready = True
} """ #check_div_J=nfem.site_wise_applicator(parameter_names=[], # # all the names of extra parameters # code=code_check_div_J, # cofields=[cofield_div_J], # position_name="coords" # ) # #check_div_J([]) integrate_div_J = nfem.site_wise_applicator(parameter_names=[ "total_current_up", "total_current_down", "total_bad_current_plus", "total_bad_current_minus" ], code=code_integrate_div_J, position_name="coords", cofields=[cofield_div_J]) print "div J integrated: ", integrate_div_J([0.0, 0.0, 0.0, 0.0]) sys.exit() # This example shows that we indeed are on the right track and the # artefacts I encuntered yesterday were just a product of working too # long... The important thing to remember is: # DO NOT COMPUTE div(sigma*grad(phi)), compute Laplace(phi) # (with modified laplace operator) to get div j. The div-grad-thingy will # do strange things when taking the gradient of phi at the boundary.