//---------
doublevar HEG_system::calcLocPerturb(Sample_point * sample) {
doublevar pot=0;
int nd=ndim();
for(int p=0; p < nperturb; p++) {
Array1 <doublevar> dist(nd), epos(nd);
int s=perturb_spin(p);
int estart, eend;
doublevar r=0;
if(s==0) { estart=0; eend=nspin(0); }
else { estart=nspin(0); eend=totnelectrons; }
for(int e=estart; e< eend; e++) {
sample->getElectronPos(e,epos);
r=0;
for(int d=0; d< nd; d++) {
doublevar del=epos(d)-perturb_pos(p,d);
while(del > latVec(d,d)*0.5) del-=latVec(d,d);
while(del < -latVec(d,d)*0.5) del+=latVec(d,d);
r+=del*del;
}
pot+=perturb_strength(p)*exp(-perturb_alpha(p)*r);
}
}
return pot;
}
void Maximize_method::maximize(Sample_point * sample,Wavefunction * wf,Config_save_point & pt) {
int nelectrons=sample->electronSize();
pt.restorePos(sample);
Maximize_fn maximizer(nelectrons*3,1,1e-12,1000,1);
maximizer.wf=wf;
maximizer.wfdata=wfdata;
maximizer.sample=sample;
maximizer.system=sys;
Array1 <doublevar> allpos(nelectrons*3+1);
Array1 <doublevar> epos(3);
int count=1;
for(int e=0; e< nelectrons; e++) {
sample->getElectronPos(e,epos);
for(int d=0; d< 3; d++) {
allpos(count++)=epos(d);
}
}
maximizer.maccheckgrad(allpos.v,nelectrons*3,0.001,nelectrons*3);
maximizer.macoptII(allpos.v,nelectrons*3);
pt.savePos(sample);
}
//-----------------------------------------
void update_positions(double * _p) {
int count=1;
Array1 <doublevar> epos(3);
int nelec=sample->electronSize();
for(int e=0; e< nelec; e++) {
for(int d=0; d< 3; d++) {
epos(d)=_p[count++];
}
sample->setElectronPos(e,epos);
}
}
void QCursor::setPos(int x, int y)
{
//clip to screen size (window server allows a sprite hotspot to be outside the screen)
if (x < 0)
x=0;
else if (x >= S60->screenWidthInPixels)
x = S60->screenWidthInPixels - 1;
if (y < 0)
y = 0;
else if (y >= S60->screenHeightInPixels)
y = S60->screenHeightInPixels - 1;
#ifndef QT_NO_CURSOR
#ifndef Q_SYMBIAN_FIXED_POINTER_CURSORS
if (S60->brokenPointerCursors && cursorSpriteVisible)
cursorSprite.d->scurs.SetPosition(TPoint(x,y));
else
#endif
S60->wsSession().SetPointerCursorPosition(TPoint(x, y));
#endif
S60->lastCursorPos = QPoint(x, y);
//send a fake mouse move event, so that enter/leave events go to the widget hierarchy
QWidget *w = QApplication::topLevelAt(S60->lastCursorPos);
if (w) {
CCoeControl* ctrl = w->effectiveWinId();
TPoint epos(x, y);
TPoint cpos = epos - ctrl->PositionRelativeToScreen();
TPointerEvent fakeEvent;
fakeEvent.iType = TPointerEvent::EMove;
fakeEvent.iModifiers = 0U;
fakeEvent.iPosition = cpos;
fakeEvent.iParentPosition = epos;
ctrl->HandlePointerEventL(fakeEvent);
}
}
void Maximize_method::run(Program_options & options, ostream & output) {
Wavefunction * wf=NULL;
Sample_point * sample=NULL;
sys->generateSample(sample);
wfdata->generateWavefunction(wf);
sample->attachObserver(wf);
int nconfig=100;
Array1 <Config_save_point> config_pos(nconfig);
Array1 <doublevar> epos(3);
Primary guidewf;
generate_sample(sample,wf,wfdata,&guidewf,nconfig,config_pos);
int nelectrons=sample->electronSize();
Properties_gather mygather;
string tablename=options.runid+".table";
ofstream tableout(tablename.c_str());
for(int e=0; e< nelectrons; e++) {
sample->getElectronPos(e,epos);
for(int d=0; d< 3; d++) {
tableout << "e" << e << "_"<< d << " ";
}
}
tableout << "elocal" << endl;
for(int i=0; i < nconfig; i++) {
maximize(sample,wf,config_pos(i));
for(int e=0; e< nelectrons; e++) {
sample->getElectronPos(e,epos);
for(int d=0; d< 3; d++) {
tableout << epos(d) << " ";
}
}
Properties_point pt;
mygather.gatherData(pt, pseudo, sys, wfdata, wf,
sample, &guidewf);
tableout << pt.energy(0) << endl;
config_pos(i).write(cout);
}
delete wf;
delete sample;
}
void World::update(float delta) {
sf::Vector2f vect(player->getSpeed());
if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
player->crouch(true);
} else {
player->crouch(false);
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
if(vect.y == 0.f) vect.y = 300.f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) {
vect.x = -player->playerSpeed;
} else if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
vect.x = player->playerSpeed;
} else {
vect.x = 0;
}
player->move(vect);
Level* curr = getLevel();
if (curr != NULL) {
std::vector<Tile*>* tiles = curr->getTileObjects();
sf::Vector2i ppos(player->getPosition());
for (auto const &ent : *tiles) {
sf::Vector2i size(ent->getSize());
sf::Vector2i epos(ent->getPosition());
}
}
player->update(delta);
camera->update(delta);
if(player->getPosition().y <= 0) {
player->setPosition(sf::Vector2i(player->getPosition().x, 0));
player->move(sf::Vector2f(player->getSpeed().x, 0));
}
}
/*!
*/
void Dmc_method::runWithVariables(Properties_manager & prop,
System * sys,
Wavefunction_data * wfdata,
Pseudopotential * pseudo,
ostream & output)
{
allocateIntermediateVariables(sys, wfdata);
if(!wfdata->supports(laplacian_update))
error("DMC doesn't support all-electron moves..please"
" change your wave function to use the new Jastrow");
cout.precision(15);
output.precision(10);
prop.setSize(wf->nfunc(), nblock, nstep, nconfig, sys,
wfdata);
restorecheckpoint(readconfig, sys, wfdata, pseudo);
prop.initializeLog(average_var);
//MB: new properties manager for forward walking (one per each length)
Array1 <Properties_manager> prop_fw;
prop_fw.Resize(fw_length.GetSize());
if(max_fw_length){
for(int s=0;s<fw_length.GetSize();s++){
string logfile, label_temp;
prop.getLog(logfile, label_temp);
char strbuff[40];
sprintf(strbuff, "%d", fw_length(s));
label_temp+="_fw";
label_temp+=strbuff;
prop_fw(s).setLog(logfile, label_temp);
prop_fw(s).setSize(wf->nfunc(), nblock, nstep, nconfig, sys,
wfdata);
prop_fw(s).initializeLog(average_var);
}
}
if(nhist==-1)
nhist=1;
doublevar teff=timestep;
for(int block=0; block < nblock; block++) {
int totkilled=0;
int totbranch=0;
int totpoints=0;
for(int step=0; step < nstep; ) {
int npsteps=min(feedback_interval, nstep-step);
Dynamics_info dinfo;
doublevar acsum=0;
doublevar deltar2=0;
Array1 <doublevar> epos(3);
doublevar avg_acceptance=0;
for(int walker=0; walker < nconfig; walker++) {
pts(walker).config_pos.restorePos(sample);
wf->updateLap(wfdata, sample);
//------Do several steps without branching
for(int p=0; p < npsteps; p++) {
pseudo->randomize();
for(int e=0; e< nelectrons; e++) {
int acc;
acc=dyngen->sample(e, sample, wf, wfdata, guidingwf,
dinfo, timestep);
if(dinfo.accepted)
deltar2+=dinfo.diffusion_rate/(nconfig*nelectrons*npsteps);
if(dinfo.accepted) {
pts(walker).age(e)=0;
}
else {
pts(walker).age(e)++;
}
avg_acceptance+=dinfo.acceptance/(nconfig*nelectrons*npsteps);
if(acc>0) acsum++;
}
totpoints++;
Properties_point pt;
if(tmoves or tmoves_sizeconsistent) { //------------------T-moves
doTmove(pt,pseudo,sys,wfdata,wf,sample,guidingwf);
} ///---------------------------------done with the T-moves
else {
mygather.gatherData(pt, pseudo, sys, wfdata, wf,
sample, guidingwf);
}
Dmc_history new_hist;
new_hist.main_en=pts(walker).prop.energy(0);
pts(walker).past_energies.push_front(new_hist);
deque<Dmc_history> & past(pts(walker).past_energies);
if(past.size() > nhist)
past.erase(past.begin()+nhist, past.end());
pts(walker).prop=pt;
if(!pure_dmc) {
pts(walker).weight*=getWeight(pts(walker),teff,etrial);
//Introduce potentially a small bias to avoid instability.
if(pts(walker).weight>max_poss_weight) pts(walker).weight=max_poss_weight;
}
else
pts(walker).weight=getWeightPURE_DMC(pts(walker),teff,etrial);
if(pts(walker).ignore_walker) {
pts(walker).ignore_walker=0;
pts(walker).weight=1;
pts(walker).prop.count=0;
}
pts(walker).prop.weight=pts(walker).weight;
//This is somewhat inaccurate..will need to change it later
//For the moment, the autocorrelation will be slightly
//underestimated
pts(walker).prop.parent=walker;
pts(walker).prop.nchildren=1;
pts(walker).prop.children(0)=walker;
pts(walker).prop.avgrets.Resize(1,average_var.GetDim(0));
for(int i=0; i< average_var.GetDim(0); i++) {
average_var(i)->randomize(wfdata,wf,sys,sample);
average_var(i)->evaluate(wfdata, wf, sys, pseudo, sample, pts(walker).prop.avgrets(0,i));
}
prop.insertPoint(step+p, walker, pts(walker).prop);
for(int i=0; i< densplt.GetDim(0); i++)
densplt(i)->accumulate(sample,pts(walker).prop.weight(0));
for(int i=0; i< nldensplt.GetDim(0); i++)
nldensplt(i)->accumulate(sample,pts(walker).prop.weight(0),
wfdata,wf);
//MB: making the history of prop.avgrets for forward walking
if(max_fw_length){
forwardWalking(walker, step+p,prop_fw);
}//if FW
}
pts(walker).config_pos.savePos(sample);
}
//---Finished moving all walkers
doublevar accept_ratio=acsum/(nconfig*nelectrons*npsteps);
teff=timestep*accept_ratio; //deltar2/rf_diffusion;
updateEtrial(feedback);
step+=npsteps;
int nkilled;
if(!pure_dmc)
nkilled=calcBranch();
else
nkilled=0;
totkilled+=nkilled;
totbranch+=nkilled;
}
///----Finished block
if(!low_io || block==nblock-1) {
savecheckpoint(storeconfig,sample);
for(int i=0; i< densplt.GetDim(0); i++)
densplt(i)->write();
for(int i=0; i< nldensplt.GetDim(0); i++)
nldensplt(i)->write(log_label);
}
if(!pure_dmc){
prop.endBlock();
}
else
prop.endBlockSHDMC();
if(max_fw_length){
for(int s=0;s<fw_length.GetSize();s++){
//prop_fw(s).endBlock();
prop_fw(s).endBlock_per_step();
}
}
totbranch=parallel_sum(totbranch);
totkilled=parallel_sum(totkilled);
totpoints=parallel_sum(totpoints);
Properties_final_average finavg;
prop.getFinal(finavg);
eref=finavg.avg(Properties_types::total_energy,0);
updateEtrial(feedback);
doublevar maxage=0;
doublevar avgage=0;
for(int w=0;w < nconfig; w++) {
for(int e=0; e< nelectrons; e++) {
if(maxage<pts(w).age(e)) maxage=pts(w).age(e);
avgage+=pts(w).age(e);
}
}
avgage/=(nconfig*nelectrons);
if(output) {
//cout << "Block " << block
// << " nconfig " << totconfig
// << " etrial " << etrial << endl;
if(global_options::rappture ) {
ofstream rapout("rappture.log");
rapout << "=RAPPTURE-PROGRESS=>" << int(100.0*doublevar(block+1)/doublevar(nblock))
<< " Diffusion Monte Carlo" << endl;
cout << "=RAPPTURE-PROGRESS=>" << int(100.0*doublevar(block+1)/doublevar(nblock))
<< " Diffusion Monte Carlo" << endl;
rapout.close();
}
output << "***" << endl;
output << "Block " << block
<< " etrial " << etrial << endl;
output << "maximum age " << maxage
<< " average age " << avgage << endl;
dyngen->showStats(output);
prop.printBlockSummary(output);
output << "Branched "
<< totbranch << " times. So a branch every "
<< doublevar(totpoints)/doublevar(totbranch)
<< " steps " << endl;
}
dyngen->resetStats();
}
if(output) {
output << "\n ----------Finished DMC------------\n\n";
prop.printSummary(output,average_var);
//MB: final printout for FW
if(max_fw_length){
for(int s=0;s<fw_length.GetSize();s++)
prop_fw(s).printSummary(output,average_var);
}
}
wfdata->clearObserver();
deallocateIntermediateVariables();
}
void
HyperElasticPhaseFieldIsoDamage::computeDamageStress()
{
Real lambda = _elasticity_tensor[_qp](0, 0, 1, 1);
Real mu = _elasticity_tensor[_qp](0, 1, 0, 1);
Real c = _c[_qp];
Real xfac = Utility::pow<2>(1.0 - c) + _kdamage;
std::vector<Real> eigval;
RankTwoTensor evec;
_ee.symmetricEigenvaluesEigenvectors(eigval, evec);
for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
_etens[i].vectorOuterProduct(evec.column(i), evec.column(i));
Real etr = 0.0;
for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
etr += eigval[i];
Real etrpos = (std::abs(etr) + etr) / 2.0;
Real etrneg = (std::abs(etr) - etr) / 2.0;
RankTwoTensor pk2pos, pk2neg;
for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
{
pk2pos += _etens[i] * (lambda * etrpos + 2.0 * mu * (std::abs(eigval[i]) + eigval[i]) / 2.0);
pk2neg += _etens[i] * (lambda * etrneg + 2.0 * mu * (std::abs(eigval[i]) - eigval[i]) / 2.0);
}
_pk2_tmp = pk2pos * xfac - pk2neg;
if (_save_state)
{
std::vector<Real> epos(LIBMESH_DIM), eneg(LIBMESH_DIM);
for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
{
epos[i] = (std::abs(eigval[i]) + eigval[i]) / 2.0;
eneg[i] = (std::abs(eigval[i]) - eigval[i]) / 2.0;
}
// sum squares of epos and eneg
Real pval(0.0), nval(0.0);
for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
{
pval += epos[i] * epos[i];
nval += eneg[i] * eneg[i];
}
// Energy with positive principal strains
const Real G0_pos = lambda * etrpos * etrpos / 2.0 + mu * pval;
const Real G0_neg = lambda * etrneg * etrneg / 2.0 + mu * nval;
// Assign history variable and derivative
if (G0_pos > _hist_old[_qp])
_hist[_qp] = G0_pos;
else
_hist[_qp] = _hist_old[_qp];
Real hist_variable = _hist_old[_qp];
if (_use_current_hist)
hist_variable = _hist[_qp];
// Elastic free energy density
_F[_qp] = hist_variable * xfac - G0_neg + _gc[_qp] / (2 * _l[_qp]) * c * c;
// derivative of elastic free energy density wrt c
_dFdc[_qp] = -hist_variable * 2.0 * (1.0 - c) * (1 - _kdamage) + _gc[_qp] / _l[_qp] * c;
// 2nd derivative of elastic free energy density wrt c
_d2Fdc2[_qp] = hist_variable * 2.0 * (1 - _kdamage) + _gc[_qp] / _l[_qp];
_dG0_dee = pk2pos;
_dpk2_dc = -pk2pos * 2.0 * (1.0 - c);
}
}
