void hart_init() {
int i;
char filename[256], filename2[256];
const char *tmp;
const char *path;
tmp = extract_option1("initial-conditions-path","ics",NULL);
if(tmp != NULL) {
path = tmp;
} else {
path = output_directory;
}
/*
// No more options are allowed.
*/
if(num_options > 0) {
cart_error("Unrecognized option: %s",options[0]);
}
#ifdef PARTICLES
sprintf( filename, "%s/PMcrd.DAT", path );
sprintf( filename2, "%s/PMcrs0.DAT", path );
restart_load_balance_cart( NULL, filename, filename2 );
read_cart_particles( filename, filename2, NULL, NULL, 0, NULL );
cart_debug("read in particles");
#endif
#ifdef HYDRO
sprintf( filename, "%s/tr_ic.dat", path );
read_hart_gas_ic(filename);
cart_debug("read in gas");
#endif /* HYDRO */
units_init();
units_update( min_level );
cart_debug("tl[min_level] = %f", tl[min_level] );
cart_debug(" a[min_level] = %f", auni[min_level] );
#ifdef HYDRO
hydro_magic( min_level );
hydro_eos( min_level );
#endif /* HYDRO */
#ifdef PARTICLES
build_mesh();
#ifdef STARFORM
for ( i = 0; i < nDim; i++ ) {
star_formation_volume_min[i] = refinement_volume_min[i];
star_formation_volume_max[i] = refinement_volume_max[i];
}
#endif /* STARFORM */
#else
for ( i = 0; i < nDim; i++ ) {
refinement_volume_min[i] = 0;
refinement_volume_max[i] = (double)num_grid;
}
#endif /* PARTICLES */
#ifdef HYDRO_TRACERS
set_hydro_tracers_to_particles();
#endif /* HYDRO_TRACERS */
if ( !buffer_enabled ) {
cart_debug("building cell buffer");
build_cell_buffer();
repair_neighbors();
}
#ifdef DEBUG
check_map();
#endif /* DEBUG */
}
bool ESceneObjectTool::ExportBreakableObjects(SExportStreams* F)
{
bool bResult = true;
CGeomPartExtractor* extractor=0;
Fbox bb;
if (!GetBox(bb)) return false;
extractor = xr_new<CGeomPartExtractor>();
extractor->Initialize(bb,EPS_L,2);
UI->SetStatus ("Export breakable objects...");
// collect verts&&faces
{
SPBItem* pb = UI->ProgressStart(m_Objects.size(),"Prepare geometry...");
for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++){
pb->Inc();
CSceneObject* obj = dynamic_cast<CSceneObject*>(*it); VERIFY(obj);
if (obj->IsStatic()){
CEditableObject *O = obj->GetReference();
const Fmatrix& T = obj->_Transform();
for(EditMeshIt M=O->FirstMesh();M!=O->LastMesh();M++)
if (!build_mesh (T,*M,extractor,SGameMtl::flBreakable,FALSE)){bResult=false;break;}
}
}
UI->ProgressEnd(pb);
}
if (!extractor->Process()) bResult = false;
// export parts
if (bResult){
SBPartVec& parts = extractor->GetParts();
SPBItem* pb = UI->ProgressStart(parts.size(),"Export Parts...");
for (SBPartVecIt p_it=parts.begin(); p_it!=parts.end(); p_it++){
pb->Inc();
SBPart* P = *p_it;
if (P->Valid()){
// export visual
AnsiString sn = AnsiString().sprintf("meshes\\brkbl#%d.ogf",(p_it-parts.begin()));
xr_string fn = Scene->LevelPath()+sn.c_str();
IWriter* W = FS.w_open(fn.c_str()); R_ASSERT(W);
if (!P->Export(*W,1)){
ELog.DlgMsg (mtError,"Invalid breakable object.");
bResult = false;
break;
}
FS.w_close (W);
// export spawn object
{
AnsiString entity_ref = "breakable_object";
ISE_Abstract* m_Data = create_entity(entity_ref.c_str()); VERIFY(m_Data);
CSE_Visual* m_Visual = m_Data->visual(); VERIFY(m_Visual);
// set params
m_Data->set_name (entity_ref.c_str());
m_Data->set_name_replace (sn.c_str());
m_Data->position().set (P->m_RefOffset);
m_Data->angle().set (P->m_RefRotate);
m_Visual->set_visual (sn.c_str(),false);
if (s_draw_dbg){
Fmatrix MX;
MX.setXYZi (P->m_RefRotate);
MX.translate_over (P->m_RefOffset);
Fvector DR = {0,0,1};
MX.transform_dir (DR);
Tools->m_DebugDraw.AppendLine(P->m_RefOffset,Fvector().mad(P->m_RefOffset,MX.k,1.f),0xFF0000FF,false,false);
}
NET_Packet Packet;
m_Data->Spawn_Write (Packet,TRUE);
F->spawn.stream.open_chunk (F->spawn.chunk++);
F->spawn.stream.w (Packet.B.data,Packet.B.count);
F->spawn.stream.close_chunk ();
destroy_entity (m_Data);
}
}else{
ELog.Msg(mtError,"Can't export invalid part #%d",p_it-parts.begin());
}
}
UI->ProgressEnd(pb);
}
// clean up
xr_delete(extractor);
return bResult;
}
bool ESceneObjectTool::ExportClimableObjects(SExportStreams* F)
{
bool bResult = true;
CGeomPartExtractor* extractor = 0;
Fbox bb;
if (!GetBox(bb))
return false;
extractor = xr_new<CGeomPartExtractor>();
extractor->Initialize (bb,EPS_L,int_max);
UI->SetStatus ("Export climable objects...");
// collect verts&&faces
{
SPBItem* pb = UI->ProgressStart(m_Objects.size(), "Prepare geometry...");
for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++)
{
pb->Inc();
CSceneObject* obj = dynamic_cast<CSceneObject*>(*it);
VERIFY (obj);
if (obj->IsStatic())
{
CEditableObject *O = obj->GetReference();
const Fmatrix& T = obj->_Transform();
for(EditMeshIt M =O->FirstMesh(); M!=O->LastMesh(); M++)
if (!build_mesh (T, *M, extractor, SGameMtl::flClimable, TRUE))
{
bResult = false;
break;
}
}
}
UI->ProgressEnd(pb);
}
if (!extractor->Process())
bResult = false;
// export parts
if (bResult)
{
SBPartVec& parts = extractor->GetParts();
SPBItem* pb = UI->ProgressStart(parts.size(),"Export Parts...");
for (SBPartVecIt p_it=parts.begin(); p_it!=parts.end(); p_it++)
{
pb->Inc ();
SBPart* P = *p_it;
if (P->Valid())
{
// export visual
AnsiString sn = AnsiString().sprintf("clmbl#%d",(p_it-parts.begin()));
Fvector local_normal = {0,0,0};
LPCSTR mat_name = NULL;
for (SBFaceVecIt it=P->m_Faces.begin(); it!=P->m_Faces.end(); it++)
{
for (u32 k=0; k<3; k++)
local_normal.add ((*it)->n[k]);
mat_name = (*it)->surf->_GameMtlName();
}
local_normal.normalize_safe ();
// export spawn object
{
AnsiString entity_ref = "climable_object";
ISE_Abstract* m_Data = create_entity(entity_ref.c_str()); VERIFY(m_Data);
ISE_Shape* m_Shape = m_Data->shape(); VERIFY(m_Shape);
// CSE_Visual* m_Visual = m_Data->visual(); VERIFY(m_Visual);
// set params
m_Data->set_name (entity_ref.c_str());
m_Data->set_name_replace (sn.c_str());
// set shape
CShapeData::shape_def shape;
shape.type = CShapeData::cfBox;
shape.data.box.scale ((P->m_BBox.max.x-P->m_BBox.min.x)*0.5f,
(P->m_BBox.max.y-P->m_BBox.min.y)*0.5f,
(P->m_BBox.max.z-P->m_BBox.min.z)*0.5f);
m_Shape->assign_shapes (&shape,1);
// orientate object
if (!OrientToNorm(local_normal,P->m_OBB.m_rotate,P->m_OBB.m_halfsize))
{
ELog.Msg(mtError,"Invalid climable object found. [%3.2f, %3.2f, %3.2f]",VPUSH(P->m_RefOffset));
}
else
{
Fmatrix M; M.set (P->m_OBB.m_rotate.i,P->m_OBB.m_rotate.j,P->m_OBB.m_rotate.k,P->m_OBB.m_translate);
M.getXYZ (P->m_RefRotate); // не i потому что в движке так
m_Data->position().set (P->m_RefOffset);
m_Data->angle().set (P->m_RefRotate);
m_Data->set_additional_info((void*)mat_name);
NET_Packet Packet;
m_Data->Spawn_Write (Packet,TRUE);
F->spawn.stream.open_chunk (F->spawn.chunk++);
F->spawn.stream.w (Packet.B.data,Packet.B.count);
F->spawn.stream.close_chunk ();
if (s_draw_dbg)
{
Tools->m_DebugDraw.AppendOBB(P->m_OBB);
M.transform_dir (local_normal);
Tools->m_DebugDraw.AppendLine(P->m_RefOffset,Fvector().mad(P->m_RefOffset,local_normal,1.f));
}
}
destroy_entity (m_Data);
}
}else
{
ELog.Msg(mtError,"Can't export invalid part #%d",p_it-parts.begin());
}
}
UI->ProgressEnd (pb);
}
// clean up
xr_delete (extractor);
return bResult;
}
main() {
bool flat = false;
//int *low, *high;
vector_t light;
surface_t screen;
// this is a vector buffer, for the transformations
// our only object have 5 vertexes, but we'll make space for 32 anyway
vector_t *pbuffer;
// off-screen surface buffer
//u_char* sbuffer = (u_char*)malloc(MODE2_MAX);
// our solid :)
object_t triangle;
heapinit (HPSIZE);
pbuffer = newa(vector_t, 32);
triangle.mesh = build_mesh();
triangle.rot_x = triangle.rot_y = triangle.rot_z = 0;
triangle.trans_x = triangle.trans_y = 0;
triangle.trans_z = i2f(30); // remember: we are using fixed-point numbers
screen.data.ram = sbuffer;
// polygon rendering buffers
//low = newa(int, MODE2_HEIGHT);
//high = newa(int, MODE2_HEIGHT);
// light source
light.x = light.y = light.z = i2f(1);
vector_normalize(&light, &light);
printf("spinning solid demo\n\n");
printf("instructions:\n press [UP] to toggle flat shading\n\n");
printf("creating look-up tables, please wait\n");
create_lookup_tables();
// set screen to graphic mode
set_color(15, 1, 1);
set_mode(mode_2);
fill(MODE2_ATTR, 0xF1, MODE2_MAX);
//surface_line(&screen, 0, 0, 0, 0); // FIXME: won't compile without this crap
while (!get_trigger(0)) {
if (get_stick(0) == 1)
flat = !flat;
// rotate a bit
triangle.rot_y += 2;
triangle.rot_x += 3;
triangle.rot_z += 1;
// clear the off-screen buffer
memset(sbuffer, 0, MODE2_MAX); // [*]
//surface_line(screen, 0, 0, 10, 10);
// render the object
if (flat)
//object_render_flatshading(&screen, &triangle, pbuffer, low, high, &light);
object_render_flatshading(&screen, &triangle, pbuffer, stencil, &light);
else
object_render_wireframe(&screen, &triangle, pbuffer);
// show the off-screen buffer
//vwrite(screen.data.ram, 0, MODE2_MAX); // [*]
msx_vwrite_direct(screen.data.ram, 0, MODE2_MAX);
// [*] FIXME: there will be better ways of doing this (soon)
}
// go back to text mode
set_mode(mode_0);
// deallocate stuff
mesh_delete(triangle.mesh);
//free(sbuffer);
//free(low);
//free(high);
//destroy_lookup_tables();
}
Interaction<number>::Interaction() {
F1_A[0] = HYDR_A;
F1_A[1] = STCK_A;
F1_RC[0] = HYDR_RC;
F1_RC[1] = STCK_RC;
F1_R0[0] = HYDR_R0;
F1_R0[1] = STCK_R0;
F1_BLOW[0] = HYDR_BLOW;
F1_BLOW[1] = STCK_BLOW;
F1_BHIGH[0] = HYDR_BHIGH;
F1_BHIGH[1] = STCK_BHIGH;
F1_RLOW[0] = HYDR_RLOW;
F1_RLOW[1] = STCK_RLOW;
F1_RHIGH[0] = HYDR_RHIGH;
F1_RHIGH[1] = STCK_RHIGH;
F1_RCLOW[0] = HYDR_RCLOW;
F1_RCLOW[1] = STCK_RCLOW;
F1_RCHIGH[0] = HYDR_RCHIGH;
F1_RCHIGH[1] = STCK_RCHIGH;
F2_K[0] = CRST_K;
F2_K[1] = CXST_K;
F2_RC[0] = CRST_RC;
F2_RC[1] = CXST_RC;
F2_R0[0] = CRST_R0;
F2_R0[1] = CXST_R0;
F2_BLOW[0] = CRST_BLOW;
F2_BLOW[1] = CXST_BLOW;
F2_BHIGH[0] = CRST_BHIGH;
F2_BHIGH[1] = CXST_BHIGH;
F2_RLOW[0] = CRST_RLOW;
F2_RLOW[1] = CXST_RLOW;
F2_RHIGH[0] = CRST_RHIGH;
F2_RHIGH[1] = CXST_RHIGH;
F2_RCLOW[0] = CRST_RCLOW;
F2_RCLOW[1] = CXST_RCLOW;
F2_RCHIGH[0] = CRST_RCHIGH;
F2_RCHIGH[1] = CXST_RCHIGH;
F4_THETA_A[0] = STCK_THETA4_A;
F4_THETA_A[1] = STCK_THETA5_A;
F4_THETA_A[2] = HYDR_THETA1_A;
F4_THETA_A[3] = HYDR_THETA2_A;
F4_THETA_A[4] = HYDR_THETA4_A;
F4_THETA_A[5] = HYDR_THETA7_A;
F4_THETA_A[6] = CRST_THETA1_A;
F4_THETA_A[7]= CRST_THETA2_A;
F4_THETA_A[8] = CRST_THETA4_A;
F4_THETA_A[9] = CRST_THETA7_A;
F4_THETA_A[10] = CXST_THETA1_A;
F4_THETA_A[11] = CXST_THETA4_A;
F4_THETA_A[12] = CXST_THETA5_A;
F4_THETA_B[0] = STCK_THETA4_B;
F4_THETA_B[1] = STCK_THETA5_B;
F4_THETA_B[2] = HYDR_THETA1_B;
F4_THETA_B[3] = HYDR_THETA2_B;
F4_THETA_B[4] = HYDR_THETA4_B;
F4_THETA_B[5] = HYDR_THETA7_B;
F4_THETA_B[6] = CRST_THETA1_B;
F4_THETA_B[7] = CRST_THETA2_B;
F4_THETA_B[8] = CRST_THETA4_B;
F4_THETA_B[9] = CRST_THETA7_B;
F4_THETA_B[10] = CXST_THETA1_B;
F4_THETA_B[11] = CXST_THETA4_B;
F4_THETA_B[12] = CXST_THETA5_B;
F4_THETA_T0[0] = STCK_THETA4_T0;
F4_THETA_T0[1] = STCK_THETA5_T0;
F4_THETA_T0[2] = HYDR_THETA1_T0;
F4_THETA_T0[3] = HYDR_THETA2_T0;
F4_THETA_T0[4] = HYDR_THETA4_T0;
F4_THETA_T0[5] = HYDR_THETA7_T0;
F4_THETA_T0[6] = CRST_THETA1_T0;
F4_THETA_T0[7] = CRST_THETA2_T0;
F4_THETA_T0[8] = CRST_THETA4_T0;
F4_THETA_T0[9] = CRST_THETA7_T0;
F4_THETA_T0[10] = CXST_THETA1_T0;
F4_THETA_T0[11] = CXST_THETA4_T0;
F4_THETA_T0[12] = CXST_THETA5_T0;
F4_THETA_TS[0] = STCK_THETA4_TS;
F4_THETA_TS[1] = STCK_THETA5_TS;
F4_THETA_TS[2] = HYDR_THETA1_TS;
F4_THETA_TS[3] = HYDR_THETA2_TS;
F4_THETA_TS[4] = HYDR_THETA4_TS;
F4_THETA_TS[5] = HYDR_THETA7_TS;
F4_THETA_TS[6] = CRST_THETA1_TS;
F4_THETA_TS[7] = CRST_THETA2_TS;
F4_THETA_TS[8] = CRST_THETA4_TS;
F4_THETA_TS[9] = CRST_THETA7_TS;
F4_THETA_TS[10] = CXST_THETA1_TS;
F4_THETA_TS[11] = CXST_THETA4_TS;
F4_THETA_TS[12] = CXST_THETA5_TS;
F4_THETA_TC[0] = STCK_THETA4_TC;
F4_THETA_TC[1] = STCK_THETA5_TC;
F4_THETA_TC[2] = HYDR_THETA1_TC;
F4_THETA_TC[3] = HYDR_THETA2_TC;
F4_THETA_TC[4] = HYDR_THETA4_TC;
F4_THETA_TC[5] = HYDR_THETA7_TC;
F4_THETA_TC[6] = CRST_THETA1_TC;
F4_THETA_TC[7] = CRST_THETA2_TC;
F4_THETA_TC[8] = CRST_THETA4_TC;
F4_THETA_TC[9] = CRST_THETA7_TC;
F4_THETA_TC[10] = CXST_THETA1_TC;
F4_THETA_TC[11] = CXST_THETA4_TC;
F4_THETA_TC[12] = CXST_THETA5_TC;
F5_PHI_A[0] = STCK_PHI1_A;
F5_PHI_A[1] = STCK_PHI2_A;
F5_PHI_A[2] = CXST_PHI3_A;
F5_PHI_A[3] = CXST_PHI4_A;
F5_PHI_B[0] = STCK_PHI1_B;
F5_PHI_B[1] = STCK_PHI2_B;
F5_PHI_B[2] = CXST_PHI3_B;
F5_PHI_B[3] = CXST_PHI3_B;
F5_PHI_XC[0] = STCK_PHI1_XC;
F5_PHI_XC[1] = STCK_PHI2_XC;
F5_PHI_XC[2] = CXST_PHI3_XC;
F5_PHI_XC[3] = CXST_PHI4_XC;
F5_PHI_XS[0] = STCK_PHI1_XS;
F5_PHI_XS[1] = STCK_PHI2_XS;
F5_PHI_XS[2] = CXST_PHI3_XS;
F5_PHI_XS[3] = CXST_PHI4_XS;
MESH_F4_POINTS[HYDR_F4_THETA1] = HYDR_T1_MESH_POINTS;
MESH_F4_POINTS[HYDR_F4_THETA2] = HYDR_T2_MESH_POINTS;
MESH_F4_POINTS[HYDR_F4_THETA4] = HYDR_T4_MESH_POINTS;
MESH_F4_POINTS[HYDR_F4_THETA7] = HYDR_T7_MESH_POINTS;
MESH_F4_POINTS[STCK_F4_THETA4] = STCK_T4_MESH_POINTS;
MESH_F4_POINTS[STCK_F4_THETA5] = STCK_T5_MESH_POINTS;
MESH_F4_POINTS[CRST_F4_THETA1] = CRST_T1_MESH_POINTS;
MESH_F4_POINTS[CRST_F4_THETA2] = CRST_T2_MESH_POINTS;
MESH_F4_POINTS[CRST_F4_THETA4] = CRST_T4_MESH_POINTS;
MESH_F4_POINTS[CRST_F4_THETA7] = CRST_T7_MESH_POINTS;
MESH_F4_POINTS[CXST_F4_THETA1] = CXST_T1_MESH_POINTS;
MESH_F4_POINTS[CXST_F4_THETA4] = CXST_T4_MESH_POINTS;
MESH_F4_POINTS[CXST_F4_THETA5] = CXST_T5_MESH_POINTS;
for (int i = 0; i < 13; i++ ) {
// the order of the interpolation interval extremes is reversed, due to
// the cosine being monotonically decreasing with increasing x
int points = MESH_F4_POINTS[i];
number upplimit = cos(fmax( 0, F4_THETA_T0[i] - F4_THETA_TC[i]));
number lowlimit = cos(fmin(PI, F4_THETA_T0[i] + F4_THETA_TC[i]));
/*
number lowlimit = fmax( 0, F4_THETA_T0[i] - F4_THETA_TC[i]);
number upplimit = fmin(PI, F4_THETA_T0[i] + F4_THETA_TC[i]);
*/
if (i != CXST_F4_THETA1)
build_mesh(&Interaction<number>::fakef4, &Interaction<number>::fakef4D, (void *)(&i), points, lowlimit, upplimit, mesh_f4[i]);
else
{
build_mesh(&Interaction<number>::fakef4sp, &Interaction<number>::fakef4Dsp, (void *)(&i), points, lowlimit, upplimit, mesh_f4[i]);
}
assert(lowlimit < upplimit);
// fprintf(stderr, "## %i %d %lf %lf\n", i, points, lowlimit, upplimit);
}
/*
//for (number x=-1; x < 1; x+=0.001) {
for (number x=0; x <= PI; x += 0.001) {
int merda = CXST_F4_THETA1;
double i = ((int) ((cos(x) - mesh_f4[merda].xlow)/mesh_f4[merda].delta) ) * mesh_f4[merda].delta + mesh_f4[merda].xlow;
printf("%lf %lf %lf %lf %d\n", x, f4(x, merda) + f4(2 * PI - x, merda), query_mesh(cos(x), mesh_f4[merda]), query_mesh(i, mesh_f4[merda]), merda);
//printf("%lf %lf %lf %lf\n", x, f4(x, merda), f4(2 * PI - x, merda), f4(x, merda) + f4(2 * PI - x, merda));
}
for (int mn = 0; mn < 13; mn ++)
{
printf("###########################################\n");
printf("# MESH N %3d ##############################\n", mn);
printf("###########################################\n");
for (int k = 0; k < mesh_f4[mn].N && k < 20; k ++)
{
printf ("%3d % 8.6lf % 8.6lf % 8.6lf % 8.6lf\n", k, mesh_f4[mn].A[k], mesh_f4[mn].B[k], mesh_f4[mn].A[k+1], mesh_f4[mn].B[k+1]);
}
printf("###########################################\n\n");
}
abort();
*/
}
void system::set_geometry(const bool init)
{
const double dt_max = 1.0/512;
scheduler = Scheduler(dt_max);
int np;
float lx, ly, lz;
FILE *fin = NULL;
if (myproc == 0)
{
float wp;
fin = fopen(fin_data, "r");
int ival;
size_t nread;
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == 2*sizeof(int));
nread = fread(&np, sizeof(int), 1, fin);
nread = fread(&wp, sizeof(float), 1, fin);
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == 2*sizeof(int));
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == 3*sizeof(float));
nread = fread(&lx, sizeof(float), 1, fin);
nread = fread(&ly, sizeof(float), 1, fin);
nread = fread(&lz, sizeof(float), 1, fin);
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == 3*sizeof(float));
fprintf(stderr, " np= %d wp= %g \n",np, wp);
fprintf(stderr, " lx= %g ly= %g lz= %g \n", lx, ly, lz);
}
MPI_Bcast(&lx, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(&ly, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(&lz, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
t_end = 0.2;
n_restart = 2;
dt_restart = dt_max;
dt_dump = 0.01;
di_log = 100;
global_n = local_n = 0;
// eulerian = true;
const vec3 rmin(0.0);
const vec3 rmax(lx, ly, lz);
global_domain = boundary(rmin, rmax);
global_domain_size = global_domain.hsize() * 2.0;
const vec3 Len3 = global_domain.hsize() * 2.0;
pfloat<0>::set_scale(Len3.x);
pfloat<1>::set_scale(Len3.y);
pfloat<2>::set_scale(Len3.z);
if (myproc == 0)
{
ptcl.resize(np);
const int nx = (int)std::pow(np, 1.0/3.0);
const dvec3 dr = dvec3(Len3.x/nx, Len3.y/nx, Len3.z/nx);
const real rmax = dr.abs() * 1.0;
fprintf(stderr, "dr= %g %g %g \n", dr.x, dr.y, dr.z);
local_n = ptcl.size();
global_n = local_n;
{
std::vector<float> x(local_n), y(local_n), z(local_n);
size_t nread;
int ival;
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
nread = fread(&x[0], sizeof(float), local_n, fin);
assert((int)nread == local_n);
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
nread = fread(&y[0], sizeof(float), local_n, fin);
assert((int)nread == local_n);
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
nread = fread(&z[0], sizeof(float), local_n, fin);
assert((int)nread == local_n);
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
for (int i = 0; i < local_n; i++)
{
const dvec3 vel(0.0, 0.0, 0.0);
ptcl[i] = Particle(x[i], y[i], z[i], vel.x, vel.y, vel.z, i);
ptcl[i].rmax = rmax;
ptcl[i].unset_derefine();
}
}
U.resize(local_n);
const int var_list[7] = {
Fluid::VELX,
Fluid::VELY,
Fluid::VELZ,
Fluid::DENS,
Fluid::BX,
Fluid::BY,
Fluid::BZ};
std::vector<float> data(local_n);
for (int var = 0; var < 7; var++)
{
fprintf(stderr, " reading vat %d out of %d \n", var+1, 7);
int ival;
size_t nread;
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
nread = fread(&data[0], sizeof(float), local_n, fin);
assert((int)nread == local_n);
nread = fread(&ival, sizeof(int), 1, fin); assert(ival == local_n*(int)sizeof(float));
for (int i = 0; i < local_n; i++)
U[i][var_list[var]] = data[i];
}
for (int i = 0; i < local_n; i++)
{
assert(U[i][Fluid::DENS] > 0.0);
U[i][Fluid::ETHM] = cs2 * U[i][Fluid::DENS];
}
fclose(fin);
fprintf(stderr, " *** proc= %d : local_n= %d global_n= %d \n", myproc, local_n, global_n);
} // myproc == 0
MPI_Bcast(&global_n, 1, MPI_INT, 0, MPI_COMM_WORLD);
fprintf(stderr, " proc= %d distrubite \n", myproc);
MPI_Barrier(MPI_COMM_WORLD);
Distribute::int3 nt(1, 1, 1);
switch(nproc) {
case 1: break;
case 2: nt.x = 2; nt.y = 1; nt.z = 1; break;
case 4: nt.x = 2; nt.y = 2; nt.z = 1; break;
case 6: nt.x = 3; nt.y = 2; nt.z = 1; break;
case 8: nt.x = 2; nt.y = 2; nt.z = 2; break;
case 16: nt.x = 4; nt.y = 2; nt.z = 2; break;
case 32: nt.x = 4; nt.y = 4; nt.z = 2; break;
case 64: nt.x = 4; nt.y = 4; nt.z = 4; break;
case 128: nt.x = 8; nt.y = 4; nt.z = 4; break;
case 256: nt.x = 8; nt.y = 8; nt.z = 4; break;
case 512: nt.x = 8; nt.y = 8; nt.z = 8; break;
default: assert(false);
}
const Distribute::int3 nt_glb(nt);
const pBoundary pglobal_domain(pfloat3(0.0), pfloat3(Len3));
distribute_glb.set(nproc, nt, pglobal_domain);
for (int k = 0; k < 5; k++)
distribute_data(true, false);
const int nloc_reserve = (int)(2.0*global_n/nproc);
fit_reserve_vec(ptcl, nloc_reserve);
fit_reserve_vec(ptcl_ppos, nloc_reserve);
fit_reserve_vec(U, nloc_reserve);
fit_reserve_vec(dU, nloc_reserve);
fit_reserve_vec(Wgrad, nloc_reserve);
fit_reserve_vec(gradPsi, nloc_reserve);
fit_reserve_vec(cells, nloc_reserve);
MPI_Barrier(MPI_COMM_WORLD);
fprintf(stderr, " *** proc= %d : local_n= %d global_n= %d \n", myproc, local_n, global_n);
fprintf(stderr, " proc= %d building_mesh \n", myproc);
MPI_Barrier(MPI_COMM_WORLD);
const double t10 = mytimer::get_wtime();
clear_mesh();
int nattempt = build_mesh(true);
double dt10 = mytimer::get_wtime() - t10;
double volume_loc = 0.0;
{
std::vector<TREAL> v(local_n);
for (int i = 0; i < local_n; i++)
v[i] = cells[i].Volume;
std::sort(v.begin(), v.end()); // sort volumes from low to high, to avoid roundoff errors
for (int i = 0; i < local_n; i++)
volume_loc += v[i];
}
double dt10max;
MPI_Allreduce(&dt10, &dt10max, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
double volume_glob = 0.0;
int nattempt_max, nattempt_min;
MPI_Allreduce(&volume_loc, &volume_glob, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(&nattempt, &nattempt_max, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
MPI_Allreduce(&nattempt, &nattempt_min, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD);
const double volume_exact = global_domain_size.x*global_domain_size.y*global_domain_size.z;
if (myproc == 0)
{
fprintf(stderr, "first call build_mesh:[ %g sec :: %g cells/s/proc/thread ]\n",
dt10max,
global_n/nproc/dt10max);
fprintf(stderr, " computed_volume= %g exact_volume= %g diff= %g [ %g ] nattempt= %d %d \n",
volume_glob, volume_exact,
volume_glob - volume_exact, (volume_glob - volume_exact)/volume_exact,
nattempt_min, nattempt_max);
}
exchange_ptcl();
}
