S2DB::S2DB( QWidget *p ) : QFrame( p )
{
setupUi( this );
Read = false;
CBar->setAutoScale( AutoScaleB->isChecked() );
S2DV->setCBar( CBar );
MCAsDirSel = new QFileDialog;
MCAsDirSel->setAcceptMode( QFileDialog::AcceptOpen );
MCAsDirSel->setDirectory( QDir::currentPath() );
qDebug() << "Cur Path" << QDir::currentPath();
MCAsDirSel->setNameFilter( "*" );
MCAsDirSel->setFileMode( QFileDialog::Directory );
MCAsDirSel->setConfirmOverwrite( false );
PopDialog = new QDialog;
PopDialog->resize( 600, 400 );
QGridLayout *bl = new QGridLayout;
PopDialog->setLayout( bl );
popping = false;
layout = NULL;
connect( PopDialog, SIGNAL( finished(int) ), this, SLOT( PopUp() ),
Qt::UniqueConnection );
connect( PopB, SIGNAL( clicked() ), this, SLOT( PopUp() ),
Qt::UniqueConnection );
connect( LoadMCAsB, SIGNAL( clicked() ), MCAsDirSel, SLOT( show() ),
Qt::UniqueConnection );
connect( MCAsDirSel, SIGNAL( fileSelected( const QString & ) ),
this, SLOT( LoadMCAs( const QString & ) ),
Qt::UniqueConnection );
#if 0
connect( S2DPopUp, SIGNAL( clicked() ), this, SIGNAL( popup() ), Qt::UniqueConnection );
connect( S2DPrintB, SIGNAL( clicked() ), this, SIGNAL( print() ), Qt::UniqueConnection );
#endif
connect( AutoScaleB, SIGNAL( toggled( bool ) ), CBar, SLOT( setAutoScale( bool ) ), Qt::UniqueConnection );
connect( zmax, SIGNAL( editingFinished() ), this, SLOT( newInputZmax() ), Qt::UniqueConnection );
connect( zmin, SIGNAL( editingFinished() ), this, SLOT( newInputZmin() ), Qt::UniqueConnection );
connect( S2DV, SIGNAL( newAutoZmax( double ) ), CBar, SLOT( newAutoZmax( double ) ), Qt::UniqueConnection );
connect( S2DV, SIGNAL( newAutoZmin( double ) ), CBar, SLOT( newAutoZmin( double ) ), Qt::UniqueConnection );
connect( CBar, SIGNAL( newZZ( QString, QString ) ), this, SLOT( newZZ( QString, QString ) ), Qt::UniqueConnection );
connect( CBar, SIGNAL( newScale() ), S2DV, SLOT( update() ), Qt::UniqueConnection );
mapLoadTimer = new QTimer;
connect( mapLoadTimer, SIGNAL( timeout() ),
this, SLOT( loadNextMap() ), Qt::UniqueConnection );
loadingMCAMap = false;
loadingAMCA = false;
mapSaveTimer = new QTimer;
connect( mapSaveTimer, SIGNAL( timeout() ),
this, SLOT( saveNextMap() ), Qt::UniqueConnection );
savingMCAMap = false;
savingAMCA = false;
}
void Matrix::scale(float x, float y, float z) {
Matrix* m = newScale(x, y, z);
Matrix* temp = new Matrix(*this);
if (m != NULL && temp != NULL) {
multiply(*temp, *m);
}
delete m;
delete temp;
}
void CelAnimMesh::setCommonScale( Shape::Mesh & otherMesh )
{
CelAnimMesh *potherMesh = dynamic_cast<CelAnimMesh *>(&otherMesh);
AssertFatal(potherMesh,
"TS::CelAnimMesh::setCommonScale: meshes not same type");
#if 0
// array of unpacked verts -- points only
Point3F *unpackedVerts = new Point3F[fVerts.size()];
int v;
for (v=0;v<fVerts.size();v++)
fVerts[v].getPoint(unpackedVerts[v],fScale,fOrigin);
Point3F *otherUnpackedVerts = new Point3F[potherMesh->fVerts.size()];
for (v=0;v<potherMesh->fVerts.size();v++)
potherMesh->fVerts[v].getPoint(otherUnpackedVerts[v],potherMesh->fScale,potherMesh->fOrigin);
// get minVert and maxVert for setting new fScale, fOrigin, and fRadius
Point3F minVert = unpackedVerts[0];
Point3F maxVert = unpackedVerts[0];
for (v=1;v<fVerts.size();v++)
{
minVert.setMin( unpackedVerts[v] );
maxVert.setMax( unpackedVerts[v] );
}
for (v=0;v<potherMesh->fVerts.size();v++)
{
minVert.setMin( otherUnpackedVerts[v] );
maxVert.setMax( otherUnpackedVerts[v] );
}
// figure new fOrigin, fScale, and fRadius
Point3F newOrigin = minVert;
maxVert -= minVert;
Point3F newScale( maxVert.x/255.0f, maxVert.y/255.0f, maxVert.z/255.0f);
float newRadius = maxVert.len();
// re-pack this shapes verts
int i;
Point3F temp;
for (i=0;i<fVerts.size();i++)
fVerts[i].setPoint(unpackedVerts[i],newScale,newOrigin);
fOrigin=newOrigin;
fScale=newScale;
fRadius=newRadius;
// re-pack other shapes verts
for (i=0;i<potherMesh->fVerts.size();i++)
potherMesh->fVerts[i].setPoint(otherUnpackedVerts[i],newScale,newOrigin);
potherMesh->fOrigin=fOrigin;
potherMesh->fScale=newScale;
potherMesh->fRadius=newRadius;
delete [] unpackedVerts;
delete [] otherUnpackedVerts;
#endif
}
void MGuiWindow::autoScale(void)
{
MVector2 tmp;
MVector2 newScale(0, 0);
unsigned int i;
unsigned int size = m_objects.size();
for(i=0; i<size; i++)
{
MGui2d * object = m_objects[i];
tmp = object->getPosition()
+ object->getScale();
if(tmp.x > newScale.x) newScale.x = tmp.x;
if(tmp.y > newScale.y) newScale.y = tmp.y;
}
setScale(newScale);
resizeScroll();
}
bool VMCcuda::runWithDrift()
{
resetRun();
IndexType block = 0;
IndexType nAcceptTot = 0;
IndexType nRejectTot = 0;
int nat = W.getTotalNum();
int nw = W.getActiveWalkers();
vector<RealType> LocalEnergy(nw), oldScale(nw), newScale(nw);
vector<PosType> delpos(nw);
vector<PosType> dr(nw);
vector<PosType> newpos(nw);
vector<ValueType> ratios(nw), rplus(nw), rminus(nw);
vector<PosType> oldG(nw), newG(nw);
vector<ValueType> oldL(nw), newL(nw);
vector<Walker_t*> accepted(nw);
Matrix<ValueType> lapl(nw, nat);
Matrix<GradType> grad(nw, nat);
// First, do warmup steps
for (int step=0; step<myWarmupSteps; step++) {
for(int iat=0; iat<nat; iat++) {
Psi.getGradient (W, iat, oldG);
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandomWithEngine(delpos,Random);
for(int iw=0; iw<nw; iw++) {
oldScale[iw] = getDriftScale(m_tauovermass,oldG[iw]);
dr[iw] = (m_sqrttau*delpos[iw]) + (oldScale[iw]*oldG[iw]);
newpos[iw]=W[iw]->R[iat] + dr[iw];
ratios[iw] = 1.0;
}
W.proposeMove_GPU(newpos, iat);
Psi.ratio(W,iat,ratios,newG, newL);
accepted.clear();
vector<bool> acc(nw, false);
for(int iw=0; iw<nw; ++iw) {
PosType drOld =
newpos[iw] - (W[iw]->R[iat] + oldScale[iw]*oldG[iw]);
RealType logGf = -m_oneover2tau * dot(drOld, drOld);
newScale[iw] = getDriftScale(m_tauovermass,newG[iw]);
PosType drNew =
(newpos[iw] + newScale[iw]*newG[iw]) - W[iw]->R[iat];
RealType logGb = -m_oneover2tau * dot(drNew, drNew);
RealType x = logGb - logGf;
RealType prob = ratios[iw]*ratios[iw]*std::exp(x);
if(Random() < prob) {
accepted.push_back(W[iw]);
nAccept++;
W[iw]->R[iat] = newpos[iw];
acc[iw] = true;
}
else
nReject++;
}
W.acceptMove_GPU(acc);
if (accepted.size())
Psi.update(accepted,iat);
}
}
// Now do data collection steps
do {
IndexType step = 0;
nAccept = nReject = 0;
Estimators->startBlock(nSteps);
do {
step++;
CurrentStep++;
for (int isub=0; isub<nSubSteps; isub++) {
for(int iat=0; iat<nat; iat++) {
Psi.getGradient (W, iat, oldG);
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandomWithEngine(delpos,Random);
for(int iw=0; iw<nw; iw++) {
oldScale[iw] = getDriftScale(m_tauovermass,oldG[iw]);
dr[iw] = (m_sqrttau*delpos[iw]) + (oldScale[iw]*oldG[iw]);
newpos[iw]=W[iw]->R[iat] + dr[iw];
ratios[iw] = 1.0;
}
W.proposeMove_GPU(newpos, iat);
Psi.ratio(W,iat,ratios,newG, newL);
accepted.clear();
vector<bool> acc(nw, false);
for(int iw=0; iw<nw; ++iw) {
PosType drOld =
newpos[iw] - (W[iw]->R[iat] + oldScale[iw]*oldG[iw]);
// if (dot(drOld, drOld) > 25.0)
// cerr << "Large drift encountered! Old drift = " << drOld << endl;
RealType logGf = -m_oneover2tau * dot(drOld, drOld);
newScale[iw] = getDriftScale(m_tauovermass,newG[iw]);
PosType drNew =
(newpos[iw] + newScale[iw]*newG[iw]) - W[iw]->R[iat];
// if (dot(drNew, drNew) > 25.0)
// cerr << "Large drift encountered! Drift = " << drNew << endl;
RealType logGb = -m_oneover2tau * dot(drNew, drNew);
RealType x = logGb - logGf;
RealType prob = ratios[iw]*ratios[iw]*std::exp(x);
if(Random() < prob) {
accepted.push_back(W[iw]);
nAccept++;
W[iw]->R[iat] = newpos[iw];
acc[iw] = true;
}
else
nReject++;
}
W.acceptMove_GPU(acc);
if (accepted.size())
Psi.update(accepted,iat);
}
// cerr << "Rank = " << myComm->rank() <<
// " CurrentStep = " << CurrentStep << " isub = " << isub << endl;
}
Psi.gradLapl(W, grad, lapl);
H.evaluate (W, LocalEnergy);
if (myPeriod4WalkerDump && (CurrentStep % myPeriod4WalkerDump)==0)
W.saveEnsemble();
Estimators->accumulate(W);
} while(step<nSteps);
Psi.recompute(W);
double accept_ratio = (double)nAccept/(double)(nAccept+nReject);
Estimators->stopBlock(accept_ratio);
nAcceptTot += nAccept;
nRejectTot += nReject;
++block;
recordBlock(block);
} while(block<nBlocks);
//finalize a qmc section
if (!myComm->rank())
gpu::cuda_memory_manager.report();
return finalize(block);
}
bool KX_IpoSGController::Update(double currentTime)
{
if (m_modified)
{
T_InterpolatorList::iterator i;
for (i = m_interpolators.begin(); !(i == m_interpolators.end()); ++i) {
(*i)->Execute(m_ipotime);//currentTime);
}
SG_Spatial* ob = (SG_Spatial*)m_pObject;
//initialization on the first frame of the IPO
if (! m_ipo_start_initialized && currentTime > 0.0) {
m_ipo_start_point = ob->GetLocalPosition();
m_ipo_start_orient = ob->GetLocalOrientation();
m_ipo_start_scale = ob->GetLocalScale();
m_ipo_start_initialized = true;
if (!m_ipo_euler_initialized) {
// do it only once to avoid angle discontinuities
m_ipo_start_orient.getEuler(m_ipo_start_euler[0], m_ipo_start_euler[1], m_ipo_start_euler[2]);
m_ipo_euler_initialized = true;
}
}
//modifies position?
if (m_ipo_channels_active[OB_LOC_X] || m_ipo_channels_active[OB_LOC_Y] || m_ipo_channels_active[OB_LOC_Z] ||
m_ipo_channels_active[OB_DLOC_X] || m_ipo_channels_active[OB_DLOC_Y] || m_ipo_channels_active[OB_DLOC_Z])
{
if (m_ipo_as_force == true)
{
if (m_game_object && ob && m_game_object->GetPhysicsController())
{
m_game_object->GetPhysicsController()->ApplyForce(m_ipo_local ?
ob->GetWorldOrientation() * m_ipo_xform.GetPosition() :
m_ipo_xform.GetPosition(), false);
}
}
else
{
// Local ipo should be defined with the object position at (0,0,0)
// Local transform is applied to the object based on initial position
MT_Point3 newPosition(0.0,0.0,0.0);
if (!m_ipo_add)
newPosition = ob->GetLocalPosition();
//apply separate IPO channels if there is any data in them
//Loc and dLoc act by themselves or are additive
//LocX and dLocX
if (m_ipo_channels_active[OB_LOC_X]) {
newPosition[0] = (m_ipo_channels_active[OB_DLOC_X] ? m_ipo_xform.GetPosition()[0] + m_ipo_xform.GetDeltaPosition()[0] : m_ipo_xform.GetPosition()[0]);
}
else if (m_ipo_channels_active[OB_DLOC_X] && m_ipo_start_initialized) {
newPosition[0] = (((!m_ipo_add)?m_ipo_start_point[0]:0.0) + m_ipo_xform.GetDeltaPosition()[0]);
}
//LocY and dLocY
if (m_ipo_channels_active[OB_LOC_Y]) {
newPosition[1] = (m_ipo_channels_active[OB_DLOC_Y] ? m_ipo_xform.GetPosition()[1] + m_ipo_xform.GetDeltaPosition()[1] : m_ipo_xform.GetPosition()[1]);
}
else if (m_ipo_channels_active[OB_DLOC_Y] && m_ipo_start_initialized) {
newPosition[1] = (((!m_ipo_add)?m_ipo_start_point[1]:0.0) + m_ipo_xform.GetDeltaPosition()[1]);
}
//LocZ and dLocZ
if (m_ipo_channels_active[OB_LOC_Z]) {
newPosition[2] = (m_ipo_channels_active[OB_DLOC_Z] ? m_ipo_xform.GetPosition()[2] + m_ipo_xform.GetDeltaPosition()[2] : m_ipo_xform.GetPosition()[2]);
}
else if (m_ipo_channels_active[OB_DLOC_Z] && m_ipo_start_initialized) {
newPosition[2] = (((!m_ipo_add)?m_ipo_start_point[2]:0.0) + m_ipo_xform.GetDeltaPosition()[2]);
}
if (m_ipo_add) {
if (m_ipo_local)
newPosition = m_ipo_start_point + m_ipo_start_scale*(m_ipo_start_orient*newPosition);
else
newPosition = m_ipo_start_point + newPosition;
}
if (m_game_object)
m_game_object->NodeSetLocalPosition(newPosition);
}
}
//modifies orientation?
if (m_ipo_channels_active[OB_ROT_X] || m_ipo_channels_active[OB_ROT_Y] || m_ipo_channels_active[OB_ROT_Z] ||
m_ipo_channels_active[OB_DROT_X] || m_ipo_channels_active[OB_DROT_Y] || m_ipo_channels_active[OB_DROT_Z])
{
if (m_ipo_as_force) {
if (m_game_object && ob) {
m_game_object->ApplyTorque(m_ipo_local ?
ob->GetWorldOrientation() * m_ipo_xform.GetEulerAngles() :
m_ipo_xform.GetEulerAngles(), false);
}
} else if (m_ipo_add) {
if (m_ipo_start_initialized) {
double yaw=0, pitch=0, roll=0; //delta Euler angles
//RotX and dRotX
if (m_ipo_channels_active[OB_ROT_X])
yaw += m_ipo_xform.GetEulerAngles()[0];
if (m_ipo_channels_active[OB_DROT_X])
yaw += m_ipo_xform.GetDeltaEulerAngles()[0];
//RotY dRotY
if (m_ipo_channels_active[OB_ROT_Y])
pitch += m_ipo_xform.GetEulerAngles()[1];
if (m_ipo_channels_active[OB_DROT_Y])
pitch += m_ipo_xform.GetDeltaEulerAngles()[1];
//RotZ and dRotZ
if (m_ipo_channels_active[OB_ROT_Z])
roll += m_ipo_xform.GetEulerAngles()[2];
if (m_ipo_channels_active[OB_DROT_Z])
roll += m_ipo_xform.GetDeltaEulerAngles()[2];
MT_Matrix3x3 rotation(MT_Vector3(yaw, pitch, roll));
if (m_ipo_local)
rotation = m_ipo_start_orient * rotation;
else
rotation = rotation * m_ipo_start_orient;
if (m_game_object)
m_game_object->NodeSetLocalOrientation(rotation);
}
} else if (m_ipo_channels_active[OB_ROT_X] || m_ipo_channels_active[OB_ROT_Y] || m_ipo_channels_active[OB_ROT_Z]) {
if (m_ipo_euler_initialized) {
// assume all channel absolute
// All 3 channels should be specified but if they are not, we will take
// the value at the start of the game to avoid angle sign reversal
double yaw=m_ipo_start_euler[0], pitch=m_ipo_start_euler[1], roll=m_ipo_start_euler[2];
//RotX and dRotX
if (m_ipo_channels_active[OB_ROT_X]) {
yaw = (m_ipo_channels_active[OB_DROT_X] ? (m_ipo_xform.GetEulerAngles()[0] + m_ipo_xform.GetDeltaEulerAngles()[0]) : m_ipo_xform.GetEulerAngles()[0] );
}
else if (m_ipo_channels_active[OB_DROT_X]) {
yaw += m_ipo_xform.GetDeltaEulerAngles()[0];
}
//RotY dRotY
if (m_ipo_channels_active[OB_ROT_Y]) {
pitch = (m_ipo_channels_active[OB_DROT_Y] ? (m_ipo_xform.GetEulerAngles()[1] + m_ipo_xform.GetDeltaEulerAngles()[1]) : m_ipo_xform.GetEulerAngles()[1] );
}
else if (m_ipo_channels_active[OB_DROT_Y]) {
pitch += m_ipo_xform.GetDeltaEulerAngles()[1];
}
//RotZ and dRotZ
if (m_ipo_channels_active[OB_ROT_Z]) {
roll = (m_ipo_channels_active[OB_DROT_Z] ? (m_ipo_xform.GetEulerAngles()[2] + m_ipo_xform.GetDeltaEulerAngles()[2]) : m_ipo_xform.GetEulerAngles()[2] );
}
else if (m_ipo_channels_active[OB_DROT_Z]) {
roll += m_ipo_xform.GetDeltaEulerAngles()[2];
}
if (m_game_object)
m_game_object->NodeSetLocalOrientation(MT_Vector3(yaw, pitch, roll));
}
} else if (m_ipo_start_initialized) {
// only DROT, treat as Add
double yaw=0, pitch=0, roll=0; //delta Euler angles
//dRotX
if (m_ipo_channels_active[OB_DROT_X])
yaw = m_ipo_xform.GetDeltaEulerAngles()[0];
//dRotY
if (m_ipo_channels_active[OB_DROT_Y])
pitch = m_ipo_xform.GetDeltaEulerAngles()[1];
//dRotZ
if (m_ipo_channels_active[OB_DROT_Z])
roll = m_ipo_xform.GetDeltaEulerAngles()[2];
// dRot are always local
MT_Matrix3x3 rotation(MT_Vector3(yaw, pitch, roll));
rotation = m_ipo_start_orient * rotation;
if (m_game_object)
m_game_object->NodeSetLocalOrientation(rotation);
}
}
//modifies scale?
if (m_ipo_channels_active[OB_SIZE_X] || m_ipo_channels_active[OB_SIZE_Y] || m_ipo_channels_active[OB_SIZE_Z] ||
m_ipo_channels_active[OB_DSIZE_X] || m_ipo_channels_active[OB_DSIZE_Y] || m_ipo_channels_active[OB_DSIZE_Z])
{
//default is no scale change
MT_Vector3 newScale(1.0,1.0,1.0);
if (!m_ipo_add)
newScale = ob->GetLocalScale();
if (m_ipo_channels_active[OB_SIZE_X]) {
newScale[0] = (m_ipo_channels_active[OB_DSIZE_X] ? (m_ipo_xform.GetScaling()[0] + m_ipo_xform.GetDeltaScaling()[0]) : m_ipo_xform.GetScaling()[0]);
}
else if (m_ipo_channels_active[OB_DSIZE_X] && m_ipo_start_initialized) {
newScale[0] = (m_ipo_xform.GetDeltaScaling()[0] + ((!m_ipo_add)?m_ipo_start_scale[0]:0.0));
}
//RotY dRotY
if (m_ipo_channels_active[OB_SIZE_Y]) {
newScale[1] = (m_ipo_channels_active[OB_DSIZE_Y] ? (m_ipo_xform.GetScaling()[1] + m_ipo_xform.GetDeltaScaling()[1]): m_ipo_xform.GetScaling()[1]);
}
else if (m_ipo_channels_active[OB_DSIZE_Y] && m_ipo_start_initialized) {
newScale[1] = (m_ipo_xform.GetDeltaScaling()[1] + ((!m_ipo_add)?m_ipo_start_scale[1]:0.0));
}
//RotZ and dRotZ
if (m_ipo_channels_active[OB_SIZE_Z]) {
newScale[2] = (m_ipo_channels_active[OB_DSIZE_Z] ? (m_ipo_xform.GetScaling()[2] + m_ipo_xform.GetDeltaScaling()[2]) : m_ipo_xform.GetScaling()[2]);
}
else if (m_ipo_channels_active[OB_DSIZE_Z] && m_ipo_start_initialized) {
newScale[2] = (m_ipo_xform.GetDeltaScaling()[2] + ((!m_ipo_add)?m_ipo_start_scale[2]:1.0));
}
if (m_ipo_add) {
newScale = m_ipo_start_scale * newScale;
}
if (m_game_object)
m_game_object->NodeSetLocalScale(newScale);
}
m_modified=false;
}
return false;
}
void CPhysicsActor::SetScale( Vec3& scale )
{
// do not scale if scale is currently 1:1 or if the scale
// has not changed
if( scale.x == 1 && scale.y == 1 && scale.z == 1 ||
scale == m_CurrentScale )
{
return;
}
// make sure the scale is valid
// No 0 scales or negative scales!
if( scale.x <= 0 && scale.y <= 0 && scale.z <= 0 )
{
m_ToolBox->Log( LOGWARNING, _T("CPhysicsActor::SetScale() Invalid scale!\n" ) );
return;
}
NxVec3 newScale( scale.x, scale.y, scale.z );
// unscale the old scale
// Loop through shapes in the actor
unsigned int numShapes = m_Actor->getNbShapes();
NxShape*const* shapes = m_Actor->getShapes();
NxShape* currentShape;
NxVec3 shapeLocalPosition;
// for each shape type scale its dimensions
while( numShapes-- >= 1 )
{
currentShape = shapes[numShapes];
// get the shape's type
NxShapeType type = currentShape->getType();
switch( type )
{
case NX_SHAPE_BOX:
{
// do something
NxBoxShape* shape = (NxBoxShape*)currentShape;
// rescale box dimensions
NxVec3 dimensions = shape->getDimensions();
Vec3 newDimensions(dimensions.x, dimensions.y, dimensions.z);
RescaleVector( newDimensions, scale );
// set the shape data with the newly rescaled dimensions
shape->setDimensions( NxVec3(newDimensions.x, newDimensions.y, newDimensions.z) );
break;
}
case NX_SHAPE_SPHERE:
{
// do something
NxSphereShape* shape = (NxSphereShape*)currentShape;
float radius = shape->getRadius();
radius /= m_CurrentScale.x;
radius *= newScale.x;
// set the shape data with the newly rescaled dimensions
shape->setRadius( radius );
break;
}
case NX_SHAPE_CAPSULE:
{
// do something
NxCapsuleShape* shape;
shape = (NxCapsuleShape*)currentShape;
// rescale radius
float radius = shape->getRadius();
radius /= m_CurrentScale.x;
radius *= newScale.x;
// rescale height
float height = shape->getHeight();
height /= m_CurrentScale.z;
height *= newScale.z;
// set the shape data with the newly rescaled dimensions
shape->setRadius( radius );
shape->setHeight( height );
break;
}
default:
m_ToolBox->Log( LOGWARNING, _T("CPhysicsObject::SetScale() Attempting to scale on unsupported shape!\n" ) );
return;
}
// get the shape's local position and rescale it
shapeLocalPosition = currentShape->getLocalPosition();
Vec3 newShapeLocalPosition(shapeLocalPosition.x, shapeLocalPosition.y, shapeLocalPosition.z);
RescaleVector( newShapeLocalPosition, scale );
currentShape->setLocalPosition( NxVec3(newShapeLocalPosition.x, newShapeLocalPosition.y, newShapeLocalPosition.z) );
}
// Set the current scale to the new scale so we can unscale the scale
m_CurrentScale = scale;
}
bool DMCcuda::run()
{
bool NLmove = NonLocalMove == "yes";
bool scaleweight = ScaleWeight == "yes";
if (NLmove)
app_log() << " Using Casula nonlocal moves in DMCcuda.\n";
if (scaleweight)
app_log() << " Scaling weight per Umrigar/Nightengale.\n";
resetRun();
Mover->MaxAge = 1;
IndexType block = 0;
IndexType nAcceptTot = 0;
IndexType nRejectTot = 0;
int nat = W.getTotalNum();
int nw = W.getActiveWalkers();
vector<RealType> LocalEnergy(nw), LocalEnergyOld(nw),
oldScale(nw), newScale(nw);
vector<PosType> delpos(nw);
vector<PosType> dr(nw);
vector<PosType> newpos(nw);
vector<ValueType> ratios(nw), rplus(nw), rminus(nw), R2prop(nw), R2acc(nw);
vector<PosType> oldG(nw), newG(nw);
vector<ValueType> oldL(nw), newL(nw);
vector<Walker_t*> accepted(nw);
Matrix<ValueType> lapl(nw, nat);
Matrix<GradType> grad(nw, nat);
vector<ValueType> V2(nw), V2bar(nw);
vector<vector<NonLocalData> > Txy(nw);
for (int iw=0; iw<nw; iw++)
W[iw]->Weight = 1.0;
do {
IndexType step = 0;
nAccept = nReject = 0;
Estimators->startBlock(nSteps);
do {
step++;
CurrentStep++;
nw = W.getActiveWalkers();
ResizeTimer.start();
LocalEnergy.resize(nw); oldScale.resize(nw);
newScale.resize(nw); delpos.resize(nw);
dr.resize(nw); newpos.resize(nw);
ratios.resize(nw); rplus.resize(nw);
rminus.resize(nw); oldG.resize(nw);
newG.resize(nw); oldL.resize(nw);
newL.resize(nw); accepted.resize(nw);
lapl.resize(nw, nat); grad.resize(nw, nat);
R2prop.resize(nw,0.0); R2acc.resize(nw,0.0);
V2.resize(nw,0.0); V2bar.resize(nw,0.0);
W.updateLists_GPU();
ResizeTimer.stop();
if (NLmove) {
Txy.resize(nw);
for (int iw=0; iw<nw; iw++) {
Txy[iw].clear();
Txy[iw].push_back(NonLocalData(-1, 1.0, PosType()));
}
}
for (int iw=0; iw<nw; iw++)
W[iw]->Age++;
DriftDiffuseTimer.start();
for(int iat=0; iat<nat; iat++) {
Psi.getGradient (W, iat, oldG);
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandomWithEngine(delpos,Random);
for(int iw=0; iw<nw; iw++) {
delpos[iw] *= m_sqrttau;
oldScale[iw] = getDriftScale(m_tauovermass,oldG[iw]);
dr[iw] = delpos[iw] + (oldScale[iw]*oldG[iw]);
newpos[iw]=W[iw]->R[iat] + dr[iw];
ratios[iw] = 1.0;
R2prop[iw] += dot(delpos[iw], delpos[iw]);
}
W.proposeMove_GPU(newpos, iat);
Psi.ratio(W,iat,ratios,newG, newL);
accepted.clear();
vector<bool> acc(nw, false);
for(int iw=0; iw<nw; ++iw) {
PosType drOld =
newpos[iw] - (W[iw]->R[iat] + oldScale[iw]*oldG[iw]);
RealType logGf = -m_oneover2tau * dot(drOld, drOld);
newScale[iw] = getDriftScale(m_tauovermass,newG[iw]);
PosType drNew =
(newpos[iw] + newScale[iw]*newG[iw]) - W[iw]->R[iat];
RealType logGb = -m_oneover2tau * dot(drNew, drNew);
RealType x = logGb - logGf;
RealType prob = ratios[iw]*ratios[iw]*std::exp(x);
if(Random() < prob && ratios[iw] > 0.0) {
accepted.push_back(W[iw]);
nAccept++;
W[iw]->R[iat] = newpos[iw];
W[iw]->Age = 0;
acc[iw] = true;
R2acc[iw] += dot(delpos[iw], delpos[iw]);
V2[iw] += m_tauovermass * m_tauovermass * dot(newG[iw],newG[iw]);
V2bar[iw] += newScale[iw] * newScale[iw] * dot(newG[iw],newG[iw]);
}
else {
nReject++;
V2[iw] += m_tauovermass * m_tauovermass * dot(oldG[iw],oldG[iw]);
V2bar[iw] += oldScale[iw] * oldScale[iw] * dot(oldG[iw],oldG[iw]);
}
}
W.acceptMove_GPU(acc);
if (accepted.size())
Psi.update(accepted,iat);
}
DriftDiffuseTimer.stop();
// Psi.recompute(W, false);
Psi.gradLapl(W, grad, lapl);
HTimer.start();
if (NLmove) H.evaluate (W, LocalEnergy, Txy);
else H.evaluate (W, LocalEnergy);
HTimer.stop();
// for (int iw=0; iw<nw; iw++) {
// branchEngine->clampEnergy(LocalEnergy[iw]);
// W[iw]->getPropertyBase()[LOCALENERGY] = LocalEnergy[iw];
// }
if (CurrentStep == 1)
LocalEnergyOld = LocalEnergy;
if (NLmove) {
// Now, attempt nonlocal move
accepted.clear();
vector<int> iatList;
vector<PosType> accPos;
for (int iw=0; iw<nw; iw++) {
/// HACK HACK HACK
// if (LocalEnergy[iw] < -2300.0) {
// cerr << "Walker " << iw << " has energy "
// << LocalEnergy[iw] << endl;;
// double maxWeight = 0.0;
// int elMax = -1;
// PosType posMax;
// for (int j=1; j<Txy[iw].size(); j++)
// if (std::fabs(Txy[iw][j].Weight) > std::fabs(maxWeight)) {
// maxWeight = Txy[iw][j].Weight;
// elMax = Txy[iw][j].PID;
// posMax = W[iw]->R[elMax] + Txy[iw][j].Delta;
// }
// cerr << "Maximum weight is " << maxWeight << " for electron "
// << elMax << " at position " << posMax << endl;
// PosType unit = W.Lattice.toUnit(posMax);
// unit[0] -= round(unit[0]);
// unit[1] -= round(unit[1]);
// unit[2] -= round(unit[2]);
// cerr << "Reduced position = " << unit << endl;
// }
int ibar = NLop.selectMove(Random(), Txy[iw]);
if (ibar) {
accepted.push_back(W[iw]);
int iat = Txy[iw][ibar].PID;
iatList.push_back(iat);
accPos.push_back(W[iw]->R[iat] + Txy[iw][ibar].Delta);
}
}
if (accepted.size()) {
Psi.ratio(accepted,iatList, accPos, ratios, newG, newL);
Psi.update(accepted,iatList);
for (int i=0; i<accepted.size(); i++)
accepted[i]->R[iatList[i]] = accPos[i];
W.NLMove_GPU (accepted, accPos, iatList);
// HACK HACK HACK
// Recompute the kinetic energy
// Psi.gradLapl(W, grad, lapl);
// H.evaluate (W, LocalEnergy);
//W.copyWalkersToGPU();
}
}
// Now branch
BranchTimer.start();
for (int iw=0; iw<nw; iw++) {
RealType v2=0.0, v2bar=0.0;
for(int iat=0; iat<nat; iat++) {
v2 += dot(W.G[iat],W.G[iat]);
RealType newscale = getDriftScale(m_tauovermass,newG[iw]);
v2 += m_tauovermass * m_tauovermass * dot(newG[iw],newG[iw]);
v2bar += newscale * newscale * dot(newG[iw],newG[iw]);
}
//RealType scNew = std::sqrt(V2bar[iw] / V2[iw]);
RealType scNew = std::sqrt(v2bar/v2);
RealType scOld = (CurrentStep == 1) ? scNew : W[iw]->getPropertyBase()[DRIFTSCALE];
W[iw]->getPropertyBase()[DRIFTSCALE] = scNew;
// fprintf (stderr, "iw = %d scNew = %1.8f scOld = %1.8f\n", iw, scNew, scOld);
RealType tauRatio = R2acc[iw] / R2prop[iw];
if (tauRatio < 0.5)
cerr << " tauRatio = " << tauRatio << endl;
RealType taueff = m_tauovermass * tauRatio;
if (scaleweight)
W[iw]->Weight *= branchEngine->branchWeightTau
(LocalEnergy[iw], LocalEnergyOld[iw], scNew, scOld, taueff);
else
W[iw]->Weight *= branchEngine->branchWeight
(LocalEnergy[iw], LocalEnergyOld[iw]);
W[iw]->getPropertyBase()[R2ACCEPTED] = R2acc[iw];
W[iw]->getPropertyBase()[R2PROPOSED] = R2prop[iw];
}
Mover->setMultiplicity(W.begin(), W.end());
branchEngine->branch(CurrentStep,W);
nw = W.getActiveWalkers();
LocalEnergyOld.resize(nw);
for (int iw=0; iw<nw; iw++)
LocalEnergyOld[iw] = W[iw]->getPropertyBase()[LOCALENERGY];
BranchTimer.stop();
} while(step<nSteps);
Psi.recompute(W, true);
double accept_ratio = (double)nAccept/(double)(nAccept+nReject);
Estimators->stopBlock(accept_ratio);
nAcceptTot += nAccept;
nRejectTot += nReject;
++block;
recordBlock(block);
} while(block<nBlocks);
//finalize a qmc section
return finalize(block);
}
bool DMCcuda::runWithNonlocal()
{
resetRun();
Mover->MaxAge = 1;
IndexType block = 0;
IndexType nAcceptTot = 0;
IndexType nRejectTot = 0;
int nat = W.getTotalNum();
int nw = W.getActiveWalkers();
vector<RealType> LocalEnergy(nw), LocalEnergyOld(nw),
oldScale(nw), newScale(nw);
vector<PosType> delpos(nw);
vector<PosType> dr(nw);
vector<PosType> newpos(nw);
vector<ValueType> ratios(nw), rplus(nw), rminus(nw), R2prop(nw), R2acc(nw);
vector<PosType> oldG(nw), newG(nw);
vector<ValueType> oldL(nw), newL(nw);
vector<Walker_t*> accepted(nw);
Matrix<ValueType> lapl(nw, nat);
Matrix<GradType> grad(nw, nat);
vector<vector<NonLocalData> > Txy(nw);
for (int iw=0; iw<nw; iw++)
W[iw]->Weight = 1.0;
do {
IndexType step = 0;
nAccept = nReject = 0;
Estimators->startBlock(nSteps);
do {
step++;
CurrentStep++;
nw = W.getActiveWalkers();
LocalEnergy.resize(nw); oldScale.resize(nw);
newScale.resize(nw); delpos.resize(nw);
dr.resize(nw); newpos.resize(nw);
ratios.resize(nw); rplus.resize(nw);
rminus.resize(nw); oldG.resize(nw);
newG.resize(nw); oldL.resize(nw);
newL.resize(nw); accepted.resize(nw);
lapl.resize(nw, nat); grad.resize(nw, nat);
R2prop.resize(nw,0.0); R2acc.resize(nw,0.0);
W.updateLists_GPU();
Txy.resize(nw);
for (int iw=0; iw<nw; iw++) {
Txy[iw].clear();
Txy[iw].push_back(NonLocalData(-1, 1.0, PosType()));
W[iw]->Age++;
}
for(int iat=0; iat<nat; iat++) {
Psi.getGradient (W, iat, oldG);
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandomWithEngine(delpos,Random);
for(int iw=0; iw<nw; iw++) {
delpos[iw] *= m_sqrttau;
oldScale[iw] = getDriftScale(m_tauovermass,oldG[iw]);
dr[iw] = delpos[iw] + (oldScale[iw]*oldG[iw]);
newpos[iw]=W[iw]->R[iat] + dr[iw];
ratios[iw] = 1.0;
R2prop[iw] += dot(delpos[iw], delpos[iw]);
}
W.proposeMove_GPU(newpos, iat);
Psi.ratio(W,iat,ratios,newG, newL);
accepted.clear();
vector<bool> acc(nw, false);
for(int iw=0; iw<nw; ++iw) {
PosType drOld =
newpos[iw] - (W[iw]->R[iat] + oldScale[iw]*oldG[iw]);
RealType logGf = -m_oneover2tau * dot(drOld, drOld);
newScale[iw] = getDriftScale(m_tauovermass,newG[iw]);
PosType drNew =
(newpos[iw] + newScale[iw]*newG[iw]) - W[iw]->R[iat];
RealType logGb = -m_oneover2tau * dot(drNew, drNew);
RealType x = logGb - logGf;
RealType prob = ratios[iw]*ratios[iw]*std::exp(x);
if(Random() < prob && ratios[iw] > 0.0) {
accepted.push_back(W[iw]);
nAccept++;
W[iw]->R[iat] = newpos[iw];
W[iw]->Age = 0;
acc[iw] = true;
R2acc[iw] += dot(delpos[iw], delpos[iw]);
}
else
nReject++;
}
W.acceptMove_GPU(acc);
if (accepted.size())
Psi.update(accepted,iat);
}
for (int iw=0; iw < nw; iw++)
if (W[iw]->Age)
cerr << "Encountered stuck walker with iw=" << iw << endl;
// Psi.recompute(W, false);
Psi.gradLapl(W, grad, lapl);
H.evaluate (W, LocalEnergy, Txy);
if (CurrentStep == 1)
LocalEnergyOld = LocalEnergy;
// Now, attempt nonlocal move
accepted.clear();
vector<int> iatList;
vector<PosType> accPos;
for (int iw=0; iw<nw; iw++) {
int ibar = NLop.selectMove(Random(), Txy[iw]);
// cerr << "Txy[iw].size() = " << Txy[iw].size() << endl;
if (ibar) {
accepted.push_back(W[iw]);
int iat = Txy[iw][ibar].PID;
iatList.push_back(iat);
accPos.push_back(W[iw]->R[iat] + Txy[iw][ibar].Delta);
}
}
if (accepted.size()) {
// W.proposeMove_GPU(newpos, iatList);
Psi.ratio(accepted,iatList, accPos, ratios, newG, newL);
Psi.update(accepted,iatList);
for (int i=0; i<accepted.size(); i++)
accepted[i]->R[iatList[i]] = accPos[i];
W.copyWalkersToGPU();
}
// Now branch
for (int iw=0; iw<nw; iw++) {
W[iw]->Weight *= branchEngine->branchWeight(LocalEnergy[iw], LocalEnergyOld[iw]);
W[iw]->getPropertyBase()[R2ACCEPTED] = R2acc[iw];
W[iw]->getPropertyBase()[R2PROPOSED] = R2prop[iw];
}
Mover->setMultiplicity(W.begin(), W.end());
branchEngine->branch(CurrentStep,W);
nw = W.getActiveWalkers();
LocalEnergyOld.resize(nw);
for (int iw=0; iw<nw; iw++)
LocalEnergyOld[iw] = W[iw]->getPropertyBase()[LOCALENERGY];
} while(step<nSteps);
Psi.recompute(W, true);
double accept_ratio = (double)nAccept/(double)(nAccept+nReject);
Estimators->stopBlock(accept_ratio);
nAcceptTot += nAccept;
nRejectTot += nReject;
++block;
recordBlock(block);
} while(block<nBlocks);
//finalize a qmc section
return finalize(block);
}
// Load the data.
void GPCMDataReader::load(
std::vector<std::string> filelist, // List of files from which to load the data.
std::vector<double> noiselist // Amount of noise to add to each file.
)
{
// Read data files.
int i = 0;
for (std::vector<std::string>::iterator itr = filelist.begin();
itr != filelist.end(); ++itr)
{
// Load the file.
MatrixXd data = loadFile(*itr);
// Load auxiliary data.
MatrixXd aux = loadAuxFile(*itr);
// Check for blank auxiliary data.
if (aux.cols() == 0)
aux.setZero(data.rows(),1);
// Add noise if desired.
addDataNoise(data,noiselist[i]);
// Concatenate into Y.
MatrixXd newY(data.rows()+Y.rows(),data.cols());
MatrixXd newAux(data.rows()+Y.rows(),aux.cols());
// Store data.
if (Y.rows() > 0)
newY << Y,data;
else
newY = data;
// Store auxiliary.
if (auxData.rows() > 0)
newAux << auxData,aux;
else
newAux = aux;
// Switch over to the new matrices.
Y = newY;
auxData = newAux;
// Concatenate into sequence.
sequence.push_back(Y.rows());
// Increment index.
i++;
}
// Do any additional processing here, such as computing velocities and building supplementary
// data structures.
postProcessData();
// Remove constant entries.
MatrixXd constantEntries;
std::vector<int> constantIndices;
std::vector<int> variableIndices;
int totalIndices = removeConstantEntries(Y,constantEntries,
constantIndices,variableIndices);
// Remove constant entries from scales.
if (supplementary->getScale().cols() > 0)
{
MatrixXd newScale(1,variableIndices.size());
for (unsigned i = 0; i < variableIndices.size(); i++)
{
newScale(0,i) = supplementary->getScale()(0,variableIndices[i]);
}
supplementary->getScale() = newScale;
}
// Pass duplicate entry information to supplement.
supplementary->setConstant(constantEntries,constantIndices,variableIndices,totalIndices);
}
unsigned int CObjTreePlugin::insertBBox(unsigned int id, const geometry_msgs::Pose &pose, const geometry_msgs::Vector3 &scale, CObjTreePlugin::Operation op)
{
printf("insertBoundingBox called, mode %d\n", op);
if(op == INSERT && m_octree.removeObject(id))
{
//Updating existing box
removePrimitiveMarker(id);
}
objtree::Point newPosition(pose.position.x, pose.position.y, pose.position.z);
objtree::Vector4f newOrientation(pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w);
objtree::Point newScale(scale.x, scale.y, scale.z);
//Compute minimal aligned bounding box
Eigen::Vector3f min, max;
Eigen::Vector3f vec[4];
vec[0] = Eigen::Vector3f(-scale.x/2.0f, -scale.y/2.0f, -scale.z/2.0f);
vec[1] = Eigen::Vector3f(-scale.x/2.0f, scale.y/2.0f, -scale.z/2.0f);
vec[2] = Eigen::Vector3f( scale.x/2.0f, -scale.y/2.0f, -scale.z/2.0f);
vec[3] = Eigen::Vector3f( scale.x/2.0f, scale.y/2.0f, -scale.z/2.0f);
Eigen::Quaternionf q(pose.orientation.w, pose.orientation.x, pose.orientation.y, pose.orientation.z);
min = max = q*vec[0];
for(int i = 1; i < 4; i++)
{
vec[i] = q*vec[i];
for(int j = 0; j < 3; j++)
{
if(min[j] > vec[i][j]) min[j] = vec[i][j];
if(max[j] < vec[i][j]) max[j] = vec[i][j];
}
}
for(int i = 0; i < 4; i++)
{
vec[i] = -vec[i];
for(int j = 0; j < 3; j++)
{
if(min[j] > vec[i][j]) min[j] = vec[i][j];
if(max[j] < vec[i][j]) max[j] = vec[i][j];
}
}
Eigen::Vector3f alignedScale(max-min);
objtree::Box alignedBox(min[0]+newPosition.x, min[1]+newPosition.y, min[2]+newPosition.z, alignedScale[0], alignedScale[1], alignedScale[2]);
objtree::GBBox *newBox = new objtree::GBBox(newPosition, newOrientation, newScale, alignedBox);
newBox->setId(id);
switch(op)
{
case INSERT: return m_octree.insert(newBox);
case UPDATE: return m_octree.insertUpdate(newBox);
case GET_SIMILAR:
{
unsigned int id = -1;
const objtree::Object *object = m_octree.getSimilarObject(newBox);
if(object)
{
id = object->id();
}
delete newBox;
return id;
}
}
return -1;
}
