void WorldSession::HandleForceSpeedChangeAckOpcodes(WorldPacket &recv_data)
{
uint32 opcode = recv_data.GetOpcode();
DEBUG_LOG("WORLD: Recvd %s (%u, 0x%X) opcode", LookupOpcodeName(opcode), opcode, opcode);
/* extract packet */
ObjectGuid guid;
MovementInfo movementInfo;
float newspeed;
recv_data >> guid;
recv_data >> Unused<uint32>(); // counter or moveEvent
recv_data >> movementInfo;
recv_data >> newspeed;
movementInfo.UpdateTime(recv_data.GetPacketTime());
// now can skip not our packet
ObjectGuid moverGuid = _player->GetMover()->GetObjectGuid();
if (guid != moverGuid && guid != _clientMoverGuid)
return;
if (!VerifyMovementInfo(movementInfo))
return;
// Process anticheat checks, remember client-side speed ...
if (_player->IsSelfMover() && !_player->GetCheatData()->HandleSpeedChangeAck(movementInfo, this, &recv_data, newspeed))
return;
// Process position-change
HandleMoverRelocation(movementInfo);
_player->UpdateFallInformationIfNeed(movementInfo, opcode);
/*----------------*/
// client ACK send one packet for mounted/run case and need skip all except last from its
// in other cases anti-cheat check can be fail in false case
UnitMoveType move_type;
switch (opcode)
{
case CMSG_FORCE_WALK_SPEED_CHANGE_ACK:
move_type = MOVE_WALK;
break;
case CMSG_FORCE_RUN_SPEED_CHANGE_ACK:
move_type = MOVE_RUN;
break;
case CMSG_FORCE_RUN_BACK_SPEED_CHANGE_ACK:
move_type = MOVE_RUN_BACK;
break;
case CMSG_FORCE_SWIM_SPEED_CHANGE_ACK:
move_type = MOVE_SWIM;
break;
case CMSG_FORCE_SWIM_BACK_SPEED_CHANGE_ACK:
move_type = MOVE_SWIM_BACK;
break;
case CMSG_FORCE_TURN_RATE_CHANGE_ACK:
move_type = MOVE_TURN_RATE;
break;
default:
sLog.outError("WorldSession::HandleForceSpeedChangeAck: Unknown move type opcode: %u", opcode);
return;
}
// Daemon TODO: enregistrement de cette position ?
// Daemon: mise a jour de la vitesse pour les joueurs a cote.
// Cf Unit::SetSpeedRate pour plus d'infos.
const uint16 SetSpeed2Opc_table[MAX_MOVE_TYPE][2] =
{
{MSG_MOVE_SET_WALK_SPEED, SMSG_FORCE_WALK_SPEED_CHANGE},
{MSG_MOVE_SET_RUN_SPEED, SMSG_FORCE_RUN_SPEED_CHANGE},
{MSG_MOVE_SET_RUN_BACK_SPEED, SMSG_FORCE_RUN_BACK_SPEED_CHANGE},
{MSG_MOVE_SET_SWIM_SPEED, SMSG_FORCE_SWIM_SPEED_CHANGE},
{MSG_MOVE_SET_SWIM_BACK_SPEED, SMSG_FORCE_SWIM_BACK_SPEED_CHANGE},
{MSG_MOVE_SET_TURN_RATE, SMSG_FORCE_TURN_RATE_CHANGE},
};
WorldPacket data(SetSpeed2Opc_table[move_type][0], 31);
data << _player->GetMover()->GetPackGUID();
data << movementInfo;
data << float(newspeed);
_player->SendMovementMessageToSet(std::move(data), false);
if (!_player->GetMover()->movespline->Finalized())
{
WorldPacket splineData(SMSG_MONSTER_MOVE, 31);
splineData << _player->GetMover()->GetPackGUID();
Movement::PacketBuilder::WriteMonsterMove(*(_player->GetMover()->movespline), splineData);
_player->SendMovementMessageToSet(std::move(splineData), false);
}
}
void EinsplineSetBuilder::ReadBands_ESHDF(int spin, EinsplineSetExtended<double>* orbitalSet)
{
update_token(__FILE__,__LINE__,"ReadBands_ESHDF:double");
ReportEngine PRE("EinsplineSetBuilder","ReadBands_ESHDF(EinsplineSetExtended<double>*");
vector<AtomicOrbital<double> > realOrbs(AtomicOrbitals.size());
for (int iat=0; iat<realOrbs.size(); iat++)
{
AtomicOrbital<complex<double> > &corb (AtomicOrbitals[iat]);
realOrbs[iat].set_pos (corb.Pos);
realOrbs[iat].set_lmax (corb.lMax);
realOrbs[iat].set_cutoff (corb.CutoffRadius);
realOrbs[iat].set_spline (corb.SplineRadius, corb.SplinePoints);
realOrbs[iat].set_polynomial (corb.PolyRadius, corb.PolyOrder);
realOrbs[iat].Lattice = corb.Lattice;
}
bool root = myComm->rank()==0;
// bcast other stuff
myComm->bcast (NumDistinctOrbitals);
myComm->bcast (NumValenceOrbs);
myComm->bcast (NumCoreOrbs);
int N = NumDistinctOrbitals;
orbitalSet->kPoints.resize(N);
orbitalSet->MakeTwoCopies.resize(N);
orbitalSet->StorageValueVector.resize(N);
orbitalSet->BlendValueVector.resize(N);
orbitalSet->StorageLaplVector.resize(N);
orbitalSet->BlendLaplVector.resize(N);
orbitalSet->StorageGradVector.resize(N);
orbitalSet->BlendGradVector.resize(N);
orbitalSet->StorageHessVector.resize(N);
orbitalSet->StorageGradHessVector.resize(N);
orbitalSet->phase.resize(N);
orbitalSet->eikr.resize(N);
orbitalSet->NumValenceOrbs = NumValenceOrbs;
orbitalSet->NumCoreOrbs = NumCoreOrbs;
orbitalSet->FirstOrderSplines.resize(IonPos.size());
// Read in k-points
int numOrbs = orbitalSet->getOrbitalSetSize();
int num = 0;
vector<BandInfo>& SortBands(*FullBands[spin]);
if (root)
{
for (int iorb=0; iorb<N; iorb++)
{
int ti = SortBands[iorb].TwistIndex;
PosType twist = TwistAngles[ti];
orbitalSet->kPoints[iorb] = orbitalSet->PrimLattice.k_cart(twist);
orbitalSet->MakeTwoCopies[iorb] =
(num < (numOrbs-1)) && SortBands[iorb].MakeTwoCopies;
num += orbitalSet->MakeTwoCopies[iorb] ? 2 : 1;
}
PosType twist0 = TwistAngles[SortBands[0].TwistIndex];
for (int i=0; i<OHMMS_DIM; i++)
if (std::fabs(std::fabs(twist0[i]) - 0.5) < 1.0e-8)
orbitalSet->HalfG[i] = 1;
else
orbitalSet->HalfG[i] = 0;
EinsplineSetBuilder::RotateBands_ESHDF(spin, orbitalSet);
}
myComm->bcast(orbitalSet->kPoints);
myComm->bcast(orbitalSet->MakeTwoCopies);
myComm->bcast(orbitalSet->HalfG);
// First, check to see if we have already read this in
H5OrbSet set(H5FileName, spin, N);
bool havePsir=!ReadGvectors_ESHDF();
app_log() << "MeshSize = (" << MeshSize[0] << ", "
<< MeshSize[1] << ", " << MeshSize[2] << ")\n";
//int nx, ny, nz, bi, ti;
int nx, ny, nz;
nx=MeshSize[0];
ny=MeshSize[1];
nz=MeshSize[2];
Ugrid x_grid, y_grid, z_grid;
BCtype_d xBC, yBC, zBC;
if (orbitalSet->HalfG[0])
{
xBC.lCode = ANTIPERIODIC;
xBC.rCode = ANTIPERIODIC;
}
else
{
xBC.lCode = PERIODIC;
xBC.rCode = PERIODIC;
}
if (orbitalSet->HalfG[1])
{
yBC.lCode = ANTIPERIODIC;
yBC.rCode = ANTIPERIODIC;
}
else
{
yBC.lCode = PERIODIC;
yBC.rCode = PERIODIC;
}
if (orbitalSet->HalfG[2])
{
zBC.lCode = ANTIPERIODIC;
zBC.rCode = ANTIPERIODIC;
}
else
{
zBC.lCode = PERIODIC;
zBC.rCode = PERIODIC;
}
x_grid.start = 0.0;
x_grid.end = 1.0;
x_grid.num = nx;
y_grid.start = 0.0;
y_grid.end = 1.0;
y_grid.num = ny;
z_grid.start = 0.0;
z_grid.end = 1.0;
z_grid.num = nz;
// Create the multiUBspline object
orbitalSet->MultiSpline =
create_multi_UBspline_3d_d (x_grid, y_grid, z_grid, xBC, yBC, zBC, NumValenceOrbs);
if (HaveOrbDerivs)
{
orbitalSet->FirstOrderSplines.resize(IonPos.size());
for (int ion=0; ion<IonPos.size(); ion++)
for (int dir=0; dir<OHMMS_DIM; dir++)
orbitalSet->FirstOrderSplines[ion][dir] =
create_multi_UBspline_3d_d (x_grid, y_grid, z_grid, xBC, yBC, zBC, NumValenceOrbs);
}
//////////////////////////////////////
// Create the MuffinTin APW splines //
//////////////////////////////////////
orbitalSet->MuffinTins.resize(NumMuffinTins);
for (int tin=0; tin<NumMuffinTins; tin++)
{
orbitalSet->MuffinTins[tin].Atom = tin;
orbitalSet->MuffinTins[tin].set_center (MT_centers[tin]);
orbitalSet->MuffinTins[tin].set_lattice(Lattice);
orbitalSet->MuffinTins[tin].init_APW
(MT_APW_rgrids[tin], MT_APW_lmax[tin],
NumValenceOrbs);
}
for (int iat=0; iat<realOrbs.size(); iat++)
{
realOrbs[iat].set_num_bands(NumValenceOrbs);
realOrbs[iat].allocate();
}
int isComplex;
if (root)
{
HDFAttribIO<int> h_isComplex(isComplex);
h_isComplex.read(H5FileID, "/electrons/psi_r_is_complex");
}
myComm->bcast(isComplex);
bool isCore = bcastSortBands(spin,N,root);
if(isCore)
{
APP_ABORT("Core states not supported by ES-HDF yet.");
}
//this is common
Array<double,3> splineData(nx,ny,nz);
if(havePsir)
{
if(isComplex)
{
app_log() << " Reading complex psi_r and convert to real" << endl;
Array<complex<double>,3> rawData;
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
int ti=SortBands[iorb].TwistIndex;
if(root)
{
ostringstream path;
path << "/electrons/kpoint_" << SortBands[iorb].TwistIndex
<< "/spin_" << spin << "/state_" << SortBands[iorb].BandIndex << "/psi_r";
HDFAttribIO<Array<complex<double>,3> > h_splineData(rawData);
h_splineData.read(H5FileID, path.str().c_str());
}
myComm->bcast(rawData);
//multiply twist factor and project on the real
fix_phase_c2r(rawData,splineData,TwistAngles[ti]);
set_multi_UBspline_3d_d (orbitalSet->MultiSpline, ival, splineData.data());
}
}
else
{
app_log() << " Reading real psi_r" << endl;
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
if(root)
{
ostringstream path;
path << "/electrons/kpoint_" << SortBands[iorb].TwistIndex
<< "/spin_" << spin << "/state_" << SortBands[iorb].BandIndex << "/psi_r";
HDFAttribIO<Array<double,3> > h_splineData(splineData);
h_splineData.read(H5FileID, path.str().c_str());
}
myComm->bcast(splineData);
set_multi_UBspline_3d_d (orbitalSet->MultiSpline, ival, splineData.data());
}
}
}
else
{
Array<ComplexType,3> FFTbox;
FFTbox.resize(MeshSize[0], MeshSize[1], MeshSize[2]);
fftw_plan FFTplan = fftw_plan_dft_3d
(MeshSize[0], MeshSize[1], MeshSize[2],
reinterpret_cast<fftw_complex*>(FFTbox.data()),
reinterpret_cast<fftw_complex*>(FFTbox.data()),
+1, FFTW_ESTIMATE);
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
Vector<complex<double> > cG;
int ncg=0;
int ti=SortBands[iorb].TwistIndex;
if(root)
{
ostringstream path;
path << "/electrons/kpoint_" << SortBands[iorb].TwistIndex
<< "/spin_" << spin << "/state_" << SortBands[iorb].BandIndex << "/psi_g";
HDFAttribIO<Vector<complex<double> > > h_cG(cG);
h_cG.read (H5FileID, path.str().c_str());
ncg=cG.size();
}
myComm->bcast(ncg);
if(ncg != Gvecs[0].size())
{
APP_ABORT("Failed : ncg != Gvecs[0].size()");
}
if(!root)
cG.resize(ncg);
myComm->bcast(cG);
unpack4fftw(cG,Gvecs[0],MeshSize,FFTbox);
fftw_execute (FFTplan);
fix_phase_rotate_c2r(FFTbox,splineData,TwistAngles[ti]);
set_multi_UBspline_3d_d (orbitalSet->MultiSpline, ival, splineData.data());
}
fftw_destroy_plan(FFTplan);
}
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
// Read atomic orbital information
for (int iat=0; iat<realOrbs.size(); iat++)
{
app_log() << "Reading orbital " << iat << " for band " << ival << endl;
AtomicOrbital<double> &orb = realOrbs[iat];
//AtomicOrbital<complex<double> > &orb = realOrbs[iat];
Array<complex<double>,2> radial_spline(orb.SplinePoints,orb.Numlm),
poly_coefs(orb.PolyOrder+1,orb.Numlm);
int ti = SortBands[iorb].TwistIndex;
if (root)
{
int bi = SortBands[iorb].BandIndex;
ostringstream path;
path << "/electrons/kpoint_" << ti << "/spin_" << spin << "/state_" << bi << "/";
ostringstream spline_path, poly_path;
spline_path << path.str() << "radial_spline_" << iat;
poly_path << path.str() << "poly_coefs_" << iat;
HDFAttribIO<Array<complex<double>,2> > h_radial_spline(radial_spline);
HDFAttribIO<Array<complex<double>,2> > h_poly_coefs(poly_coefs);
h_radial_spline.read(H5FileID, spline_path.str().c_str());
h_poly_coefs.read (H5FileID, poly_path.str().c_str());
}
myComm->bcast(radial_spline);
myComm->bcast(poly_coefs);
realOrbs[iat].set_band (ival, radial_spline, poly_coefs, TwistAngles[ti]);
}
}
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
// Now read muffin tin data
for (int tin=0; tin<NumMuffinTins; tin++)
{
// app_log() << "Reading data for muffin tin " << tin << endl;
PosType twist, k;
int lmax = MT_APW_lmax[tin];
int numYlm = (lmax+1)*(lmax+1);
Array<complex<double>,2>
u_lm_r(numYlm, MT_APW_num_radial_points[tin]);
Array<complex<double>,1> du_lm_dr (numYlm);
int ti = SortBands[iorb].TwistIndex;
if (root)
{
int bi = SortBands[iorb].BandIndex;
twist = TwistAngles[ti];
k = orbitalSet->PrimLattice.k_cart(twist);
string uName = MuffinTinPath (ti, bi,tin) + "u_lm_r";
string duName = MuffinTinPath (ti, bi,tin) + "du_lm_dr";
HDFAttribIO<Array<complex<double>,2> > h_u_lm_r(u_lm_r);
HDFAttribIO<Array<complex<double>,1> > h_du_lm_dr(du_lm_dr);
h_u_lm_r.read(H5FileID, uName.c_str());
h_du_lm_dr.read(H5FileID, duName.c_str());
}
myComm->bcast(u_lm_r);
myComm->bcast(du_lm_dr);
myComm->bcast(k);
double Z = (double)IonTypes(tin);
OrbitalSet->MuffinTins[tin].set_APW (ival, k, u_lm_r, du_lm_dr, Z);
}
}
//FIX HaveOrbDerivs after debugging
// // Now read orbital derivatives if we have them
// if (HaveOrbDerivs) {
// for (int ion=0; ion<IonPos.size(); ion++)
// for (int dim=0; dim<OHMMS_DIM; dim++) {
// if (root) {
// int ti = SortBands[iorb].TwistIndex;
// int bi = SortBands[iorb].BandIndex;
//
// app_log() << "Reading orbital derivative for ion " << ion
// << " dim " << dim << " spin " << spin << " band "
// << bi << " kpoint " << ti << endl;
// ostringstream path;
// path << "/electrons/kpoint_" << ti << "/spin_" << spin << "/state_" << bi << "/"
// << "dpsi_" << ion << "_" << dim << "_r";
// string psirName = path.str();
// if (isComplex) {
// HDFAttribIO<Array<complex<double>,3> > h_rawData(rawData);
// h_rawData.read(H5FileID, psirName.c_str());
// if ((rawData.size(0) != nx) ||
// (rawData.size(1) != ny) ||
// (rawData.size(2) != nz)) {
// fprintf (stderr, "Error in EinsplineSetBuilder::ReadBands.\n");
// fprintf (stderr, "Extended orbitals should all have the same dimensions\n");
// abort();
// }
//#pragma omp parallel for
// for (int ix=0; ix<nx; ix++) {
// PosType ru;
// ru[0] = (RealType)ix / (RealType)nx;
// for (int iy=0; iy<ny; iy++) {
// ru[1] = (RealType)iy / (RealType)ny;
// for (int iz=0; iz<nz; iz++) {
// ru[2] = (RealType)iz / (RealType)nz;
// double phi = -2.0*M_PI*dot (ru, TwistAngles[ti]);
// double s, c;
// sincos(phi, &s, &c);
// complex<double> phase(c,s);
// complex<double> z = phase*rawData(ix,iy,iz);
// splineData(ix,iy,iz) = z.real();
// }
// }
// }
// }
// else {
// HDFAttribIO<Array<double,3> > h_splineData(splineData);
// h_splineData.read(H5FileID, psirName.c_str());
// if ((splineData.size(0) != nx) ||
// (splineData.size(1) != ny) ||
// (splineData.size(2) != nz)) {
// fprintf (stderr, "Error in EinsplineSetBuilder::ReadBands.\n");
// fprintf (stderr, "Extended orbitals should all have the same dimensions\n");
// abort();
// }
// }
// }
// myComm->bcast(splineData);
// set_multi_UBspline_3d_d
// (orbitalSet->FirstOrderSplines[ion][dim], ival, splineData.data());
// }
// }
//
//
//
orbitalSet->AtomicOrbitals = realOrbs;
for (int i=0; i<orbitalSet->AtomicOrbitals.size(); i++)
orbitalSet->AtomicOrbitals[i].registerTimers();
//ExtendedMap_d[set] = orbitalSet->MultiSpline;
}
void
MPC::init_spline()
{
Array<complex<double>,3> rBox(SplineDim[0], SplineDim[1], SplineDim[2]),
GBox(SplineDim[0], SplineDim[1], SplineDim[2]);
Array<double,3> splineData(SplineDim[0], SplineDim[1], SplineDim[2]);
GBox = complex<double>();
Vconst = 0.0;
// Now fill in elements of GBox
double vol = PtclRef->Lattice.Volume;
double volInv = 1.0/vol;
for (int iG=0; iG < Gvecs.size(); iG++)
{
TinyVector<int,OHMMS_DIM> gint = Gints[iG];
PosType G = Gvecs[iG];
double G2 = dot(G,G);
TinyVector<int,OHMMS_DIM> index;
for (int j=0; j<OHMMS_DIM; j++)
index[j] = (gint[j] + SplineDim[j]) % SplineDim[j];
if (!(index[0]==0 && index[1]==0 && index[2]==0))
{
GBox(index[0], index[1], index[2]) = vol *
Rho_G[iG] * (4.0*M_PI*volInv/G2 - f_G[iG]);
Vconst -= 0.5 * vol * vol * norm(Rho_G[iG])
* (4.0*M_PI*volInv/G2 - f_G[iG]);
}
}
// G=0 component calculated seperately
GBox(0,0,0) = -vol * f_0 * Rho_G[0];
Vconst += 0.5 * vol * vol * f_0 * norm(Rho_G[0]);
app_log() << " Constant potential = " << Vconst << endl;
fftw_plan fft = fftw_plan_dft_3d
(SplineDim[0], SplineDim[1], SplineDim[2], (fftw_complex*)GBox.data(),
(fftw_complex*) rBox.data(), -1, FFTW_ESTIMATE);
fftw_execute (fft);
fftw_destroy_plan (fft);
for (int i0=0; i0<SplineDim[0]; i0++)
for (int i1=0; i1<SplineDim[1]; i1++)
for (int i2=0; i2<SplineDim[2]; i2++)
splineData(i0, i1, i2) = real(rBox(i0,i1,i2));
BCtype_d bc0, bc1, bc2;
Ugrid grid0, grid1, grid2;
grid0.start=0.0;
grid0.end=1.0;
grid0.num = SplineDim[0];
grid1.start=0.0;
grid1.end=1.0;
grid1.num = SplineDim[1];
grid2.start=0.0;
grid2.end=1.0;
grid2.num = SplineDim[2];
bc0.lCode = bc0.rCode = PERIODIC;
bc1.lCode = bc1.rCode = PERIODIC;
bc2.lCode = bc2.rCode = PERIODIC;
VlongSpline = create_UBspline_3d_d (grid0, grid1, grid2, bc0, bc1, bc2,
splineData.data());
// grid0.num = PtclRef->Density_r.size(0);
// grid1.num = PtclRef->Density_r.size(1);
// grid2.num = PtclRef->Density_r.size(2);
// DensitySpline = create_UBspline_3d_d (grid0, grid1, grid2, bc0, bc1, bc2,
// PtclRef->Density_r.data());
}
void EinsplineSetBuilder::ReadBands_ESHDF(int spin, EinsplineSetExtended<complex<double > >* orbitalSet)
{
update_token(__FILE__,__LINE__,"ReadBands_ESHDF:complex");
ReportEngine PRE("EinsplineSetBuilder","ReadBands_ESHDF(EinsplineSetExtended<complex<double > >*");
Timer c_prep, c_unpack,c_fft, c_phase, c_spline, c_newphase, c_h5, c_init;
double t_prep=0.0, t_unpack=0.0, t_fft=0.0, t_phase=0.0, t_spline=0.0, t_newphase=0.0, t_h5=0.0, t_init=0.0;
c_prep.restart();
bool root = myComm->rank()==0;
vector<BandInfo>& SortBands(*FullBands[spin]);
// bcast other stuff
myComm->bcast (NumDistinctOrbitals);
myComm->bcast (NumValenceOrbs);
myComm->bcast (NumCoreOrbs);
int N = NumDistinctOrbitals;
orbitalSet->kPoints.resize(N);
orbitalSet->MakeTwoCopies.resize(N);
orbitalSet->StorageValueVector.resize(N);
orbitalSet->BlendValueVector.resize(N);
orbitalSet->StorageLaplVector.resize(N);
orbitalSet->BlendLaplVector.resize(N);
orbitalSet->StorageGradVector.resize(N);
orbitalSet->BlendGradVector.resize(N);
orbitalSet->StorageHessVector.resize(N);
orbitalSet->StorageGradHessVector.resize(N);
orbitalSet->phase.resize(N);
orbitalSet->eikr.resize(N);
orbitalSet->NumValenceOrbs = NumValenceOrbs;
orbitalSet->NumCoreOrbs = NumCoreOrbs;
// Read in k-points
int numOrbs = orbitalSet->getOrbitalSetSize();
int num = 0;
if (root)
{
for (int iorb=0; iorb<N; iorb++)
{
int ti = SortBands[iorb].TwistIndex;
PosType twist = TwistAngles[ti];
orbitalSet->kPoints[iorb] = orbitalSet->PrimLattice.k_cart(twist);
orbitalSet->MakeTwoCopies[iorb] =
(num < (numOrbs-1)) && SortBands[iorb].MakeTwoCopies;
num += orbitalSet->MakeTwoCopies[iorb] ? 2 : 1;
}
}
myComm->bcast(orbitalSet->kPoints);
myComm->bcast(orbitalSet->MakeTwoCopies);
// First, check to see if we have already read this in
H5OrbSet set(H5FileName, spin, N);
///check mesh or ready for FFT grid
bool havePsig=ReadGvectors_ESHDF();
app_log() << "MeshSize = (" << MeshSize[0] << ", " << MeshSize[1] << ", " << MeshSize[2] << ")\n";
int nx, ny, nz, bi, ti;
nx=MeshSize[0];
ny=MeshSize[1];
nz=MeshSize[2];
Ugrid x_grid, y_grid, z_grid;
BCtype_z xBC, yBC, zBC;
xBC.lCode = PERIODIC;
xBC.rCode = PERIODIC;
yBC.lCode = PERIODIC;
yBC.rCode = PERIODIC;
zBC.lCode = PERIODIC;
zBC.rCode = PERIODIC;
x_grid.start = 0.0;
x_grid.end = 1.0;
x_grid.num = nx;
y_grid.start = 0.0;
y_grid.end = 1.0;
y_grid.num = ny;
z_grid.start = 0.0;
z_grid.end = 1.0;
z_grid.num = nz;
// Create the multiUBspline object
orbitalSet->MultiSpline =
create_multi_UBspline_3d_z (x_grid, y_grid, z_grid, xBC, yBC, zBC, NumValenceOrbs);
//////////////////////////////////////
// Create the MuffinTin APW splines //
//////////////////////////////////////
orbitalSet->MuffinTins.resize(NumMuffinTins);
for (int tin=0; tin<NumMuffinTins; tin++)
{
orbitalSet->MuffinTins[tin].Atom = tin;
orbitalSet->MuffinTins[tin].set_center (MT_centers[tin]);
orbitalSet->MuffinTins[tin].set_lattice(Lattice);
orbitalSet->MuffinTins[tin].init_APW
(MT_APW_rgrids[tin], MT_APW_lmax[tin],
NumValenceOrbs);
}
for (int iat=0; iat<AtomicOrbitals.size(); iat++)
{
AtomicOrbitals[iat].set_num_bands(NumValenceOrbs);
AtomicOrbitals[iat].allocate();
}
int isComplex=1;
if (root)
{
HDFAttribIO<int> h_isComplex(isComplex);
h_isComplex.read(H5FileID, "/electrons/psi_r_is_complex");
}
myComm->bcast(isComplex);
if (!isComplex)
{
APP_ABORT("Expected complex orbitals in ES-HDF file, but found real ones.");
}
EinsplineSetBuilder::RotateBands_ESHDF(spin, orbitalSet);
bool isCore = bcastSortBands(spin,N,root);
if(isCore)
{
APP_ABORT("Core states not supported by ES-HDF yet.");
}
t_prep += c_prep.elapsed();
/** For valence orbitals,
* - extended orbitals either in G or in R
* - localized orbitals
*/
//this can potentially break
Array<ComplexType,3> splineData(nx,ny,nz);
if(havePsig)//perform FFT using FFTW
{
c_init.restart();
Array<ComplexType,3> FFTbox;
FFTbox.resize(MeshSize[0], MeshSize[1], MeshSize[2]);
fftw_plan FFTplan = fftw_plan_dft_3d
(MeshSize[0], MeshSize[1], MeshSize[2],
reinterpret_cast<fftw_complex*>(FFTbox.data()),
reinterpret_cast<fftw_complex*>(FFTbox.data()),
+1, FFTW_ESTIMATE);
Vector<complex<double> > cG(MaxNumGvecs);
//this will be parallelized with OpenMP
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
//Vector<complex<double> > cG;
int ncg=0;
int ti=SortBands[iorb].TwistIndex;
c_h5.restart();
if(root)
{
ostringstream path;
path << "/electrons/kpoint_" << SortBands[iorb].TwistIndex
<< "/spin_" << spin << "/state_" << SortBands[iorb].BandIndex << "/psi_g";
HDFAttribIO<Vector<complex<double> > > h_cG(cG);
h_cG.read (H5FileID, path.str().c_str());
ncg=cG.size();
}
myComm->bcast(ncg);
if(ncg != Gvecs[0].size())
{
APP_ABORT("Failed : ncg != Gvecs[0].size()");
}
if(!root)
cG.resize(ncg);
myComm->bcast(cG);
t_h5 += c_h5.elapsed();
c_unpack.restart();
unpack4fftw(cG,Gvecs[0],MeshSize,FFTbox);
t_unpack+= c_unpack.elapsed();
c_fft.restart();
fftw_execute (FFTplan);
t_fft+= c_fft.elapsed();
c_phase.restart();
fix_phase_rotate_c2c(FFTbox,splineData,TwistAngles[ti]);
t_phase+= c_phase.elapsed();
c_spline.restart();
set_multi_UBspline_3d_z(orbitalSet->MultiSpline, ival, splineData.data());
t_spline+= c_spline.elapsed();
}
fftw_destroy_plan(FFTplan);
t_init+=c_init.elapsed();
}
else
{
//this will be parallelized with OpenMP
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
//check dimension
if(root)
{
ostringstream path;
path << "/electrons/kpoint_" << SortBands[iorb].TwistIndex
<< "/spin_" << spin << "/state_" << SortBands[iorb].BandIndex << "/psi_r";
HDFAttribIO<Array<complex<double>,3> > h_splineData(splineData);
h_splineData.read(H5FileID, path.str().c_str());
}
myComm->bcast(splineData);
set_multi_UBspline_3d_z(orbitalSet->MultiSpline, ival, splineData.data());
}
//return true;
}
app_log() << " READBANDS::PREP = " << t_prep << endl;
app_log() << " READBANDS::H5 = " << t_h5 << endl;
app_log() << " READBANDS::UNPACK = " << t_unpack << endl;
app_log() << " READBANDS::FFT = " << t_fft << endl;
app_log() << " READBANDS::PHASE = " << t_phase << endl;
app_log() << " READBANDS::SPLINE = " << t_spline << endl;
app_log() << " READBANDS::SUM = " << t_init << endl;
//now localized orbitals
for(int iorb=0,ival=0; iorb<N; ++iorb, ++ival)
{
PosType twist=TwistAngles[SortBands[iorb].TwistIndex];
// Read atomic orbital information
for (int iat=0; iat<AtomicOrbitals.size(); iat++)
{
app_log() << "Reading orbital " << iat << " for band " << ival << endl;
AtomicOrbital<complex<double> > &orb = AtomicOrbitals[iat];
Array<complex<double>,2> radial_spline(orb.SplinePoints,orb.Numlm),
poly_coefs(orb.PolyOrder+1,orb.Numlm);
if (root)
{
int ti = SortBands[iorb].TwistIndex;
int bi = SortBands[iorb].BandIndex;
ostringstream path;
path << "/electrons/kpoint_" << ti << "/spin_" << spin << "/state_" << bi << "/";
AtomicOrbital<complex<double> > &orb = AtomicOrbitals[iat];
ostringstream spline_path, poly_path;
spline_path << path.str() << "radial_spline_" << iat;
poly_path << path.str() << "poly_coefs_" << iat;
HDFAttribIO<Array<complex<double>,2> > h_radial_spline(radial_spline);
HDFAttribIO<Array<complex<double>,2> > h_poly_coefs(poly_coefs);
h_radial_spline.read(H5FileID, spline_path.str().c_str());
h_poly_coefs.read (H5FileID, poly_path.str().c_str());
// cerr << "radial_spline.size = (" << radial_spline.size(0)
// << ", " << radial_spline.size(1) << ")\n";
// cerr << "poly_coefs.size = (" << poly_coefs.size(0)
// << ", " << poly_coefs.size(1) << ")\n";
}
myComm->bcast(radial_spline);
myComm->bcast(poly_coefs);
AtomicOrbitals[iat].set_band (ival, radial_spline, poly_coefs, twist);
}
// Now read muffin tin data
for (int tin=0; tin<NumMuffinTins; tin++)
{
// app_log() << "Reading data for muffin tin " << tin << endl;
PosType twist, k;
int lmax = MT_APW_lmax[tin];
int numYlm = (lmax+1)*(lmax+1);
Array<complex<double>,2>
u_lm_r(numYlm, MT_APW_num_radial_points[tin]);
Array<complex<double>,1> du_lm_dr (numYlm);
if (root)
{
int ti = SortBands[iorb].TwistIndex;
int bi = SortBands[iorb].BandIndex;
twist = TwistAngles[ti];
k = orbitalSet->PrimLattice.k_cart(twist);
string uName = MuffinTinPath (ti, bi,tin) + "u_lm_r";
string duName = MuffinTinPath (ti, bi,tin) + "du_lm_dr";
HDFAttribIO<Array<complex<double>,2> > h_u_lm_r(u_lm_r);
HDFAttribIO<Array<complex<double>,1> > h_du_lm_dr(du_lm_dr);
h_u_lm_r.read(H5FileID, uName.c_str());
h_du_lm_dr.read(H5FileID, duName.c_str());
}
myComm->bcast(u_lm_r);
myComm->bcast(du_lm_dr);
myComm->bcast(k);
double Z = (double)IonTypes(tin);
OrbitalSet->MuffinTins[tin].set_APW (ival, k, u_lm_r, du_lm_dr, Z);
}
}
orbitalSet->AtomicOrbitals = AtomicOrbitals;
for (int i=0; i<orbitalSet->AtomicOrbitals.size(); i++)
orbitalSet->AtomicOrbitals[i].registerTimers();
//ExtendedMap_z[set] = orbitalSet->MultiSpline;
}
