Value Vector_UB32::nreverse()
{
INDEX len = length();
if (len > 0)
{
INDEX i = 0;
INDEX j = len - 1;
if (_data)
{
while (i < j)
{
unsigned int temp = _data[i];
_data[i] = _data[j];
_data[j] = temp;
++i;
--j;
}
}
else
{
// displaced
while (i < j)
{
Value temp = aref(i);;
aset(i, aref(j));
aset(j, temp);
++i;
--j;
}
}
}
return make_value(this);
}
/* Temporarily overlay text describing the key commands and wait for a
* keypress.
*/
static int runhelp(void)
{
int i, n, x, y;
aset(a_overlay);
mvaddstr(yDice, xDice - 1, "Use these letter keys to select the dice:");
x = xDice + cxDie;
for (i = ctl_dice ; i < ctl_dice_end ; ++i) {
mvprintw(yDice + cyDie - 2, x - 3, "(%c)", toupper(controls[i].key));
x += cxDie + cxDieSpacing;
}
mvaddstr(yButton - 1, xDice - 1, "Use (space) or (return)");
mvaddstr(yButton, xDice + 1, "to push the button:");
mvaddstr(ySlots - 1, xDice - 1,
"Use these keys to select a scoring slot:");
i = ctl_slots;
x = xSlots;
while (i < ctl_slots_end) {
for (n = 0 ; n < ctl_slots_count / 2 ; ++n, ++i)
if (controls[i].key)
mvprintw(ySlots + n, x - 4, "(%c)", toupper(controls[i].key));
x += cxSlot + cxSlotSpacing;
}
y = ySlots + cySlots;
mvaddstr(y + 0, xDice - 1, "(ctrl A) changes how the dice are drawn.");
mvaddstr(y + 1, xDice - 1, "Use (?) or (F1) to view this help again.");
mvaddstr(y + 2, xDice - 1, "Use (ctrl R) to view the rules.");
mvaddstr(y + 3, xDice - 1,
"Use (ctrl V) to see version and license information.");
mvaddstr(y + 5, xDice + cxDice - 33, "Use (ctrl X) to exit the program.");
aset(a_normal);
move(cyScreen - 1, 0);
refresh();
for (;;) {
switch (getch()) {
case '\003':
case '\030':
return 0;
case '\022':
return runruleshelp();
break;
case '\026':
return runlicensedisplay();
break;
default:
render();
return 1;
}
}
}
/* set I/O arrays to zero. Default routine */
void problem_zero(bench_problem *p)
{
bench_complex czero = {0, 0};
if (p->kind == PROBLEM_COMPLEX) {
caset((bench_complex *) p->inphys, p->iphyssz, czero);
caset((bench_complex *) p->outphys, p->ophyssz, czero);
} else if (p->kind == PROBLEM_R2R) {
aset((bench_real *) p->inphys, p->iphyssz, 0.0);
aset((bench_real *) p->outphys, p->ophyssz, 0.0);
} else if (p->kind == PROBLEM_REAL && p->sign < 0) {
aset((bench_real *) p->inphys, p->iphyssz, 0.0);
caset((bench_complex *) p->outphys, p->ophyssz, czero);
} else if (p->kind == PROBLEM_REAL && p->sign > 0) {
caset((bench_complex *) p->inphys, p->iphyssz, czero);
aset((bench_real *) p->outphys, p->ophyssz, 0.0);
} else {
BENCH_ASSERT(0); /* TODO */
}
}
/* mktree - make a tree of nodes with depth d. */
static obj_t mktree(mps_ap_t ap, unsigned d, obj_t leaf) {
obj_t tree;
size_t i;
if (d <= 0) return leaf;
tree = mkvector(ap, width);
for (i = 0; i < width; ++i) {
aset(tree, i, mktree(ap, d - 1, leaf));
}
return tree;
}
/* Update tree to be identical tree but with nodes reallocated
* with probability pupdate. This avoids writing to vector slots
* if unecessary. */
static obj_t update_tree(mps_ap_t ap, obj_t oldtree, unsigned d) {
obj_t tree;
size_t i;
if (oldtree == objNULL || d == 0)
return oldtree;
if (rnd_double() < pupdate) {
tree = mkvector(ap, width);
for (i = 0; i < width; ++i) {
aset(tree, i, update_tree(ap, aref(oldtree, i), d - 1));
}
} else {
tree = oldtree;
for (i = 0; i < width; ++i) {
obj_t oldsubtree = aref(oldtree, i);
obj_t subtree = update_tree(ap, oldsubtree, d - 1);
if (subtree != oldsubtree) {
aset(tree, i, subtree);
}
}
}
return tree;
}
void Vector_UB32::fill(Value value)
{
unsigned int n = check_ub32(value);
if (_data)
{
for (INDEX i = 0; i < _capacity; i++)
_data[i] = n;
}
else
{
for (INDEX i = 0; i < _capacity; i++)
aset(i, value);
}
}
/* new_tree - Make a new tree from an old tree.
* The new tree is the same depth as the old tree and
* reuses old nodes with probability preuse.
* NOTE: If a new node is reused multiple times, the total size
* will be smaller.
* NOTE: Changing preuse will dramatically change how much work
* is done. In particular, if preuse==1, the old tree is returned
* unchanged. */
static obj_t new_tree(mps_ap_t ap, obj_t oldtree, unsigned d) {
obj_t subtree;
size_t i;
if (rnd_double() < preuse) {
subtree = random_subtree(oldtree, depth - d);
} else {
if (d == 0)
return objNULL;
subtree = mkvector(ap, width);
for (i = 0; i < width; ++i) {
aset(subtree, i, new_tree(ap, oldtree, d - 1));
}
}
return subtree;
}
// FIXME enforce array-dimension-limit
// FIXME not thread-safe
void Vector_UB32::ensure_capacity(INDEX n)
{
if (_data)
{
if (_capacity < n)
{
// FIXME check for overflow
INDEX new_capacity = _capacity * 2;
if (new_capacity < n)
new_capacity = n;
unsigned int * new_data =
(unsigned int *) GC_malloc_atomic(new_capacity * sizeof(unsigned int));
INDEX i;
INDEX limit = length();
for (i = 0; i < limit; i++)
new_data[i] = _data[i];
while (i < new_capacity)
new_data[i++] = 0;
_data = new_data;
_capacity = new_capacity;
}
}
else
{
// displaced
if (_capacity < n || _array->total_size() - _offset < n)
{
// copy array
// FIXME check for overflow
INDEX new_capacity = _capacity * 2;
if (new_capacity < n)
new_capacity = n;
_data = (unsigned int *) GC_malloc_atomic(new_capacity * sizeof(unsigned int));
INDEX limit = _capacity;
if (limit > _array->total_size() - _offset)
limit = _array->total_size() - _offset;
for (INDEX i = 0; i < limit; i++)
aset(i, _array->aref(i + _offset));
_capacity = new_capacity;
_array = NULL;
_offset = 0;
}
}
}
array_error install_irq_handler (irq_t irq, irq_handler handler)
{
return aset(irq_handler_table,irq,handler);
}
SPOSetBase*
EinsplineSetBuilder::createSPOSet(xmlNodePtr cur)
{
//use 2 bohr as the default when truncated orbitals are used based on the extend of the ions
BufferLayer=2.0;
OhmmsAttributeSet attribs;
int numOrbs = 0;
qafm=0;
int sortBands(1);
string sourceName;
string spo_prec("double");
string truncate("no");
#if defined(QMC_CUDA)
string useGPU="yes";
#else
string useGPU="no";
#endif
attribs.add (H5FileName, "href");
attribs.add (TileFactor, "tile");
attribs.add (sortBands, "sort");
attribs.add (qafm, "afmshift");
attribs.add (TileMatrix, "tilematrix");
attribs.add (TwistNum, "twistnum");
attribs.add (givenTwist, "twist");
attribs.add (sourceName, "source");
attribs.add (MeshFactor, "meshfactor");
attribs.add (useGPU, "gpu");
attribs.add (spo_prec, "precision");
attribs.add (truncate, "truncate");
attribs.add (BufferLayer, "buffer");
attribs.put (XMLRoot);
attribs.add (numOrbs, "size");
attribs.add (numOrbs, "norbs");
attribs.put (cur);
///////////////////////////////////////////////
// Read occupation information from XML file //
///////////////////////////////////////////////
cur = cur->children;
int spinSet = -1;
vector<int> Occ_Old(0,0);
Occ.resize(0,0);
bool NewOcc(false);
while (cur != NULL)
{
string cname((const char*)(cur->name));
if(cname == "occupation")
{
string occ_mode("ground");
occ_format="energy";
particle_hole_pairs=0;
OhmmsAttributeSet oAttrib;
oAttrib.add(occ_mode,"mode");
oAttrib.add(spinSet,"spindataset");
oAttrib.add(occ_format,"format");
oAttrib.add(particle_hole_pairs,"pairs");
oAttrib.put(cur);
if(occ_mode == "excited")
{
putContent(Occ,cur);
}
else
if(occ_mode != "ground")
{
app_error() << "Only ground state occupation currently supported "
<< "in EinsplineSetBuilder.\n";
APP_ABORT("EinsplineSetBuilder::createSPOSet");
}
}
cur = cur->next;
}
if (Occ != Occ_Old)
{
NewOcc=true;
Occ_Old = Occ;
}
else
NewOcc=false;
#if defined(QMC_CUDA)
app_log() << "\t QMC_CUDA=1 Overwriting the precision of the einspline storage on the host.\n";
spo_prec="double"; //overwrite
#endif
H5OrbSet aset(H5FileName, spinSet, numOrbs);
std::map<H5OrbSet,SPOSetBase*,H5OrbSet>::iterator iter;
iter = SPOSetMap.find (aset);
if ((iter != SPOSetMap.end() ) && (!NewOcc) && (qafm==0))
{
qafm=0;
app_log() << "SPOSet parameters match in EinsplineSetBuilder: "
<< "cloning EinsplineSet object.\n";
return iter->second->makeClone();
}
// The tiling can be set by a simple vector, (e.g. 2x2x2), or by a
// full 3x3 matrix of integers. If the tilematrix was not set in
// the input file...
bool matrixNotSet = true;
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
matrixNotSet = matrixNotSet && (TileMatrix(i,j) == 0);
// then set the matrix to what may have been specified in the
// tiling vector
if (matrixNotSet)
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
TileMatrix(i,j) = (i==j) ? TileFactor(i) : 0;
if (myComm->rank() == 0)
fprintf (stderr, " [ %2d %2d %2d\n %2d %2d %2d\n %2d %2d %2d ]\n",
TileMatrix(0,0), TileMatrix(0,1), TileMatrix(0,2),
TileMatrix(1,0), TileMatrix(1,1), TileMatrix(1,2),
TileMatrix(2,0), TileMatrix(2,1), TileMatrix(2,2));
if (numOrbs == 0)
{
app_error() << "You must specify the number of orbitals in the input file.\n";
APP_ABORT("EinsplineSetBuilder::createSPOSet");
}
else
app_log() << " Reading " << numOrbs << " orbitals from HDF5 file.\n";
Timer mytimer;
mytimer.restart();
/////////////////////////////////////////////////////////////////
// Read the basic orbital information, without reading all the //
// orbitals themselves. //
/////////////////////////////////////////////////////////////////
if (myComm->rank() == 0)
if (!ReadOrbitalInfo())
{
app_error() << "Error reading orbital info from HDF5 file. Aborting.\n";
APP_ABORT("EinsplineSetBuilder::createSPOSet");
}
app_log() << "TIMER EinsplineSetBuilder::ReadOrbitalInfo " << mytimer.elapsed() << endl;
myComm->barrier();
mytimer.restart();
BroadcastOrbitalInfo();
app_log() << "TIMER EinsplineSetBuilder::BroadcastOrbitalInfo " << mytimer.elapsed() << endl;
app_log().flush();
///////////////////////////////////////////////////////////////////
// Now, analyze the k-point mesh to figure out the what k-points //
// are needed //
///////////////////////////////////////////////////////////////////
PrimCell.set(Lattice);
SuperCell.set(SuperLattice);
for (int iat=0; iat<AtomicOrbitals.size(); iat++)
AtomicOrbitals[iat].Lattice = Lattice;
// Copy supercell into the ParticleSets
// app_log() << "Overwriting XML lattice with that from the ESHDF file.\n";
// PtclPoolType::iterator piter;
// for(piter = ParticleSets.begin(); piter != ParticleSets.end(); piter++)
// piter->second->Lattice.copy(SuperCell);
AnalyzeTwists2();
//////////////////////////////////
// Create the OrbitalSet object
//////////////////////////////////
if (HaveLocalizedOrbs)
OrbitalSet = new EinsplineSetLocal;
#ifdef QMC_CUDA
else
if (AtomicOrbitals.size() > 0)
{
if (UseRealOrbitals)
OrbitalSet = new EinsplineSetHybrid<double>;
else
OrbitalSet = new EinsplineSetHybrid<complex<double> >;
}
#endif
else
{
if (UseRealOrbitals)
OrbitalSet = new EinsplineSetExtended<double>;
else
OrbitalSet = new EinsplineSetExtended<complex<double> >;
}
//set the internal parameters
setTiling(OrbitalSet,numOrbs);
if (HaveLocalizedOrbs)
{
EinsplineSetLocal *restrict orbitalSet =
dynamic_cast<EinsplineSetLocal*>(OrbitalSet);
#pragma omp critical(read_einspline_orbs)
{
if ((spinSet == LastSpinSet) && (numOrbs <= NumOrbitalsRead) && (!NewOcc) )
CopyBands(numOrbs);
else
{
// Now, figure out occupation for the bands and read them
OccupyBands(spinSet, sortBands);
ReadBands (spinSet, orbitalSet);
}
}
// Now, store what we have read
LastOrbitalSet = OrbitalSet;
LastSpinSet = spinSet;
NumOrbitalsRead = numOrbs;
}
else // Otherwise, use EinsplineSetExtended
{
mytimer.restart();
bool use_single= (spo_prec == "single" || spo_prec == "float");
if (UseRealOrbitals)
{
OccupyBands(spinSet, sortBands);
//check if a matching BsplineReaderBase exists
BsplineReaderBase* spline_reader=0;
//if(TargetPtcl.Lattice.SuperCellEnum != SUPERCELL_BULK && truncate=="yes")
if(truncate=="yes")
{
if(use_single)
{
if(TargetPtcl.Lattice.SuperCellEnum == SUPERCELL_OPEN)
spline_reader= new SplineMixedAdoptorReader<SplineOpenAdoptor<float,double,3> >(this);
else
if(TargetPtcl.Lattice.SuperCellEnum == SUPERCELL_SLAB)
spline_reader= new SplineMixedAdoptorReader<SplineMixedAdoptor<float,double,3> >(this);
else
spline_reader= new SplineAdoptorReader<SplineR2RAdoptor<float,double,3> >(this);
}
else
{
if(TargetPtcl.Lattice.SuperCellEnum == SUPERCELL_OPEN)
spline_reader= new SplineMixedAdoptorReader<SplineOpenAdoptor<double,double,3> >(this);
else
if(TargetPtcl.Lattice.SuperCellEnum == SUPERCELL_SLAB)
spline_reader= new SplineMixedAdoptorReader<SplineMixedAdoptor<double,double,3> >(this);
else
spline_reader= new SplineAdoptorReader<SplineR2RAdoptor<double,double,3> >(this);
}
}
else
{
if(use_single)
spline_reader= new SplineAdoptorReader<SplineR2RAdoptor<float,double,3> >(this);
}
if(spline_reader)
{
HasCoreOrbs=bcastSortBands(NumDistinctOrbitals,myComm->rank()==0);
SPOSetBase* bspline_zd=spline_reader->create_spline_set(spinSet,OrbitalSet);
delete spline_reader;
if(bspline_zd)
SPOSetMap[aset] = bspline_zd;
return bspline_zd;
}
else
{
app_log() << ">>>> Creating EinsplineSetExtended<double> <<<< " << endl;
EinsplineSetExtended<double> *restrict orbitalSet =
dynamic_cast<EinsplineSetExtended<double>* > (OrbitalSet);
if (Format == ESHDF)
ReadBands_ESHDF(spinSet,orbitalSet);
else
ReadBands(spinSet, orbitalSet);
}
}
else
{
OccupyBands(spinSet, sortBands);
BsplineReaderBase* spline_reader=0;
if(truncate == "yes")
{
app_log() << " Truncated orbitals with multiple kpoints are not supported yet!" << endl;
}
if(use_single)
{
#if defined(QMC_COMPLEX)
spline_reader= new SplineAdoptorReader<SplineC2CPackedAdoptor<float,double,3> >(this);
#else
spline_reader= new SplineAdoptorReader<SplineC2RPackedAdoptor<float,double,3> >(this);
#endif
}
if(spline_reader)
{
RotateBands_ESHDF(spinSet, dynamic_cast<EinsplineSetExtended<complex<double> >*>(OrbitalSet));
HasCoreOrbs=bcastSortBands(NumDistinctOrbitals,myComm->rank()==0);
SPOSetBase* bspline_zd=spline_reader->create_spline_set(spinSet,OrbitalSet);
delete spline_reader;
if(bspline_zd)
SPOSetMap[aset] = bspline_zd;
return bspline_zd;
}
else
{
EinsplineSetExtended<complex<double> > *restrict orbitalSet =
dynamic_cast<EinsplineSetExtended<complex<double> >*>(OrbitalSet);
if (Format == ESHDF)
ReadBands_ESHDF(spinSet,orbitalSet);
else
ReadBands(spinSet, orbitalSet);
}
}
app_log() << "TIMER EinsplineSetBuilder::ReadBands " << mytimer.elapsed() << endl;
}
#ifndef QMC_COMPLEX
if (myComm->rank()==0 && OrbitalSet->MuffinTins.size() > 0)
{
FILE *fout = fopen ("TestMuffins.dat", "w");
Vector<double> phi(numOrbs), lapl(numOrbs);
Vector<PosType> grad(numOrbs);
ParticleSet P;
P.R.resize(6);
for (int i=0; i<P.R.size(); i++)
P.R[i] = PosType (0.0, 0.0, 0.0);
PosType N = 0.25*PrimCell.a(0) + 0.25*PrimCell.a(1) + 0.25*PrimCell.a(2);
for (double x=-1.0; x<=1.0; x+=0.0000500113412)
{
// for (double x=-0.003; x<=0.003; x+=0.0000011329343481381) {
P.R[0] = x * (PrimCell.a(0) + 0.914*PrimCell.a(1) +
0.781413*PrimCell.a(2));
double r = std::sqrt(dot(P.R[0], P.R[0]));
double rN = std::sqrt(dot(P.R[0]-N, P.R[0]-N));
OrbitalSet->evaluate(P, 0, phi, grad, lapl);
// OrbitalSet->evaluate(P, 0, phi);
fprintf (fout, "%1.12e ", r*x/std::fabs(x));
for (int j=0; j<numOrbs; j++)
{
double gmag = std::sqrt(dot(grad[j],grad[j]));
fprintf (fout, "%16.12e ",
/*phi[j]*phi[j]**/(-5.0/r -0.5*lapl[j]/phi[j]));
// double E = -5.0/r -0.5*lapl[j]/phi[j];
fprintf (fout, "%16.12e ", phi[j]);
fprintf (fout, "%16.12e ", gmag);
}
fprintf (fout, "\n");
}
fclose(fout);
}
#endif
SPOSetMap[aset] = OrbitalSet;
if (sourceName.size() && (ParticleSets.find(sourceName) == ParticleSets.end()))
{
app_log() << " EinsplineSetBuilder creates a ParticleSet " << sourceName << endl;
ParticleSet* ions=new ParticleSet;
ions->Lattice=TargetPtcl.Lattice;
ESHDFIonsParser ap(*ions,H5FileID,myComm);
ap.put(XMLRoot);
ap.expand(TileMatrix);
ions->setName(sourceName);
ParticleSets[sourceName]=ions;
//overwrite the lattice and assign random
if(TargetPtcl.Lattice.SuperCellEnum)
{
TargetPtcl.Lattice=ions->Lattice;
makeUniformRandom(TargetPtcl.R);
TargetPtcl.R.setUnit(PosUnit::LatticeUnit);
TargetPtcl.convert2Cart(TargetPtcl.R);
TargetPtcl.createSK();
}
}
#ifdef QMC_CUDA
if (useGPU == "yes" || useGPU == "1")
{
app_log() << "Initializing GPU data structures.\n";
OrbitalSet->initGPU();
}
#endif
return OrbitalSet;
}
/* Update the display.
*/
static void render(void)
{
static char const *buttontext[bval_count] = {
"Roll Dice", " Score ", " Again "
};
static char const *slottext[ctl_slots_count] = {
"Ones", "Twos", "Threes", "Fours", "Fives", "Sixes", "Subtotal",
"Bonus", "Three of a Kind", "Four of a Kind", "Full House",
"Small Straight", "Large Straight", "Yahtzee", "Chance", "Total Score"
};
char const *text;
int i, n, x;
erase();
/* The dice. */
x = xDice;
for (i = ctl_dice ; i < ctl_dice_end ; ++i) {
if (isselected(controls[i]))
aset(a_marked);
drawacsdie(yDice, x, controls[i].value);
if (isselected(controls[i]))
aset(a_normal);
x += cxDie + cxDieSpacing;
}
/* The button. */
text = buttontext[controls[ctl_button].value];
move(yButton, xButton);
if (isdisabled(controls[ctl_button])) {
aset(a_dim);
printw("| %s |", text);
aset(a_normal);
} else if (isselected(controls[ctl_button])) {
addstr("[[");
aset(a_selected);
addstr(text);
aset(a_normal);
addstr("]]");
} else {
printw("[ %s ]", text);
}
/* The scoring slots. */
i = ctl_slots;
x = xSlots;
while (i < ctl_slots_end) {
for (n = 0 ; n < ctl_slots_count / 2 ; ++n, ++i) {
move(ySlots + n, x);
if (isselected(controls[i]))
aset(a_selected);
printw("%-*s", cxSlot - 3, slottext[i - ctl_slots]);
if (controls[i].value >= 0) {
if (isdisabled(controls[i]) || isselected(controls[i]))
printw("%3d", controls[i].value);
}
aset(a_normal);
}
x += cxSlot + cxSlotSpacing;
}
move(cyScreen - 1, 0);
refresh();
}