static long bf_refine_element(long subdiv, Element *elem, Interaction *inter, long process_id)
{
Element *e_dst = inter->destination ;
Interaction *pi ;
float visibility_val ;
long new_inter = 0 ;
visibility_val = NO_VISIBILITY_NECESSARY(subdiv)?
(float)1.0 : VISIBILITY_UNDEF ;
if( REFINE_PATCH_1(subdiv) )
{
/* Refine this element */
/* (1) Make sure it has children */
subdivide_element( elem, process_id ) ;
/* (2) For each of the patch, create an interaction */
if( element_completely_invisible( elem->center, e_dst, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem->center, e_dst, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem->center, pi, process_id ) ;
new_inter++ ;
}
if( element_completely_invisible( elem->top, e_dst, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem->top, e_dst, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem->top, pi, process_id ) ;
new_inter++ ;
}
if( element_completely_invisible( elem->left, e_dst, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem->left, e_dst, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem->left, pi, process_id ) ;
new_inter++ ;
}
if( element_completely_invisible( elem->right, e_dst, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem->right, e_dst, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem->right, pi, process_id ) ;
new_inter++ ;
}
}
else
{
/* Refine source element */
/* (1) Make sure it has children */
subdivide_element( e_dst, process_id ) ;
/* (2) Insert four new interactions
NOTE: Use *inter as a place holder to link 4 new interactions
since *prev may be NULL */
if( element_completely_invisible( elem, e_dst->center, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem, e_dst->center, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem, pi, process_id ) ;
new_inter++ ;
}
if( element_completely_invisible( elem, e_dst->top, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem, e_dst->top, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem, pi, process_id ) ;
new_inter++ ;
}
if( element_completely_invisible( elem, e_dst->left, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem, e_dst->left, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem, pi, process_id ) ;
new_inter++ ;
}
if( element_completely_invisible( elem, e_dst->right, process_id ) == 0 )
{
pi = get_interaction(process_id) ;
compute_formfactor( elem, e_dst->right, pi, process_id ) ;
pi->visibility = visibility_val ;
insert_vis_undef_interaction( elem, pi, process_id ) ;
new_inter++ ;
}
}
return( new_inter ) ;
}
static PyObject * py_get_interaction(PyObject *self, PyObject *args)
{
PyArrayObject* fc3_normal_squared_py;
PyArrayObject* frequencies;
PyArrayObject* eigenvectors;
PyArrayObject* grid_point_triplets;
PyArrayObject* grid_address_py;
PyArrayObject* mesh_py;
PyArrayObject* shortest_vectors;
PyArrayObject* multiplicity;
PyArrayObject* fc3_py;
PyArrayObject* atomic_masses;
PyArrayObject* p2s_map;
PyArrayObject* s2p_map;
PyArrayObject* band_indicies_py;
double cutoff_frequency;
int symmetrize_fc3_q;
if (!PyArg_ParseTuple(args, "OOOOOOOOOOOOOid",
&fc3_normal_squared_py,
&frequencies,
&eigenvectors,
&grid_point_triplets,
&grid_address_py,
&mesh_py,
&fc3_py,
&shortest_vectors,
&multiplicity,
&atomic_masses,
&p2s_map,
&s2p_map,
&band_indicies_py,
&symmetrize_fc3_q,
&cutoff_frequency)) {
return NULL;
}
Darray* fc3_normal_squared = convert_to_darray(fc3_normal_squared_py);
Darray* freqs = convert_to_darray(frequencies);
/* npy_cdouble and lapack_complex_double may not be compatible. */
/* So eigenvectors should not be used in Python side */
Carray* eigvecs = convert_to_carray(eigenvectors);
Iarray* triplets = convert_to_iarray(grid_point_triplets);
const int* grid_address = (int*)grid_address_py->data;
const int* mesh = (int*)mesh_py->data;
Darray* fc3 = convert_to_darray(fc3_py);
Darray* svecs = convert_to_darray(shortest_vectors);
Iarray* multi = convert_to_iarray(multiplicity);
const double* masses = (double*)atomic_masses->data;
const int* p2s = (int*)p2s_map->data;
const int* s2p = (int*)s2p_map->data;
const int* band_indicies = (int*)band_indicies_py->data;
get_interaction(fc3_normal_squared,
freqs,
eigvecs,
triplets,
grid_address,
mesh,
fc3,
svecs,
multi,
masses,
p2s,
s2p,
band_indicies,
symmetrize_fc3_q,
cutoff_frequency);
free(fc3_normal_squared);
free(freqs);
free(eigvecs);
free(triplets);
free(fc3);
free(svecs);
free(multi);
Py_RETURN_NONE;
}
void ff_refine_elements(Element *e1, Element *e2, long level, long process_id)
{
long subdiv_advice ;
Interaction i12, i21 ;
Interaction *inter ;
#if PATCH_ASSIGNMENT == PATCH_ASSIGNMENT_COSTBASED
Patch_Cost *pc1, *pc2 ;
long cost1, cost2 ;
#endif
/* Now compute formfactor.
As the BSP tree is being modified at this moment, don't test
visibility. */
compute_formfactor( e1, e2, &i12, process_id ) ;
compute_formfactor( e2, e1, &i21, process_id ) ;
/* Analyze the error of FF */
subdiv_advice = error_analysis( e1, e2, &i12, &i21, process_id ) ;
/* Execute subdivision procedure */
if( NO_INTERACTION(subdiv_advice) )
/* Two elements are mutually invisible. Do nothing */
return ;
else if( NO_REFINEMENT_NECESSARY(subdiv_advice) )
{
/* Create links and finish the job */
inter = get_interaction(process_id) ;
*inter = i12 ;
inter->visibility = VISIBILITY_UNDEF ;
insert_vis_undef_interaction( e1, inter, process_id ) ;
inter = get_interaction(process_id) ;
*inter = i21 ;
inter->visibility = VISIBILITY_UNDEF ;
insert_vis_undef_interaction( e2, inter, process_id ) ;
#if PATCH_ASSIGNMENT == PATCH_ASSIGNMENT_COSTBASED
/* Update cost variable */
pc1 = &global->patch_cost[ e1->patch->seq_no ] ;
pc2 = &global->patch_cost[ e2->patch->seq_no ] ;
if( pc1->n_total_inter <= 13 )
cost1 = (long)ceil(e1->area / Area_epsilon) ;
else
cost1 = 1 ;
if( pc2->n_total_inter <= 13 )
cost2 = (long)ceil(e2->area / Area_epsilon) ;
else
cost2 = 1 ;
LOCK(global->cost_sum_lock);
pc1->cost_estimate += cost1 ;
pc1->n_total_inter++ ;
pc2->cost_estimate += cost2 ;
pc2->n_total_inter++ ;
global->cost_estimate_sum += (cost1 + cost2) ;
global->cost_sum += (cost1 + cost2) ;
UNLOCK(global->cost_sum_lock);
#endif
}
else if( REFINE_PATCH_1(subdiv_advice) )
{
/* Refine patch 1 */
subdivide_element( e1, process_id ) ;
/* Locally solve it */
ff_refine_elements( e1->top, e2, level+1, process_id ) ;
ff_refine_elements( e1->center, e2, level+1, process_id ) ;
ff_refine_elements( e1->left, e2, level+1, process_id ) ;
ff_refine_elements( e1->right, e2, level+1, process_id ) ;
}
else
{
/* Refine patch 2 */
subdivide_element( e2, process_id ) ;
/* Locally solve it */
ff_refine_elements( e1, e2->top, level+1, process_id ) ;
ff_refine_elements( e1, e2->center, level+1, process_id ) ;
ff_refine_elements( e1, e2->left, level+1, process_id ) ;
ff_refine_elements( e1, e2->right, level+1, process_id ) ;
}
}