std::vector<Csf> Csf::distributeNonSpinAdapted (const int n, const int sp, const IrrepVector &sym, const int left, const int right, const int edge, int integralIndex) { std::vector<Csf> s; int na = 0; int nb = 0; na = (n + sp) / 2; nb = (n - sp) / 2; // let's count how many left and right orbitals there actually are int actualOrbs = right - left; int actualNA, actualNB; actualNA = actualNB = 0; for (int i=left; i<right; ++i) { if((SpinOf(i) == 1)) ++actualNA; else ++actualNB; } // cannot form this combination if (na > actualNA || nb > actualNB || na < 0 || nb < 0) { return s; } // now make orbital occupancies std::vector<int> alphaSeed (actualNA); std::vector<int> betaSeed (actualNB); for (int i = 0; i < na; ++i) alphaSeed [i] = -1; for (int i = 0; i < nb; ++i) betaSeed [i] = -1; // okay now make some permutations (at most GUESS_PERMUTATIONS) std::vector< std::vector<int> > alphaList; alphaList.push_back (alphaSeed); std::vector< std::vector<int> > betaList; betaList.push_back (betaSeed); int numberOfGuesses = dmrginp.guess_permutations(); while (next_permutation (alphaSeed.begin (), alphaSeed.end ()) && numberOfGuesses--) alphaList.push_back (alphaSeed); numberOfGuesses = dmrginp.guess_permutations();; while (next_permutation (betaSeed.begin (), betaSeed.end ()) && numberOfGuesses--) betaList.push_back (betaSeed); // okay - we have all the permutations. // make list of available alpha and beta orbitals in energy ordering. std::vector<int> orbitalAlphaList; std::vector<int> orbitalBetaList; multimap <double, int> alphaMap; multimap <double, int> betaMap; int alphaIndex = 0; int betaIndex = 0; // scan orbitals from left to right, pick out orbitals which are occupied in the hartree-fock reference for (int i=left; i<right; ++i) { if (dmrginp.hf_occupancy()[i]) { if ((SpinOf(i) == 1)) // 0 to take into account case of nospin { orbitalAlphaList.push_back(alphaIndex); ++alphaIndex; } else { orbitalBetaList.push_back(betaIndex); ++betaIndex; } } else if ((SpinOf(i) == 1)) // not HF orb, but alpha orb { alphaMap.insert(pair<double, int>(v_1[integralIndex](i, i), alphaIndex)); ++alphaIndex; } else // beta orb { betaMap.insert(pair<double, int>(v_1[integralIndex](i, i), betaIndex)); ++betaIndex; } } for (multimap<double, int>::iterator m=alphaMap.begin (); m!=alphaMap.end (); ++m) orbitalAlphaList.push_back(m->second); for (multimap<double, int>::iterator m=betaMap.begin (); m!=betaMap.end (); ++m) orbitalBetaList.push_back(m->second); // Now convert permutation lists to energy ordered form for (int i=0; i<alphaList.size (); ++i) ConvertList (alphaList[i], orbitalAlphaList); for (int i=0; i<betaList.size (); ++i) ConvertList (betaList[i], orbitalBetaList); // Now catenate to make Slaters for (int i=0; i<alphaList.size(); ++i) for (int j=0; j<betaList.size(); ++j) { std::vector<bool> lbuffer(left, 0); std::vector<bool> rbuffer(edge - right, 0); std::vector<bool> orbs(right - left); int alphaI = 0; int betaI = 0; for (int orbI=0; orbI<right-left; ++orbI) { if (SpinOf(orbI + left) == 1) { if (alphaList[i][alphaI]) orbs[orbI] = 1; ++alphaI; } else { if (betaList[j][betaI]) orbs[orbI] = 1; ++betaI; } } std::vector<bool> tmp = lbuffer; for (std::vector<bool>::iterator it = orbs.begin(); it!=orbs.end(); ++it) tmp.push_back(*it); for (std::vector<bool>::iterator it = rbuffer.begin(); it!=rbuffer.end(); ++it) tmp.push_back(*it); Slater new_det = Slater (Orbstring (tmp)); map<Slater, double> m; m[new_det] = 1.0; if(sym.getirrep() == AbelianSymmetryOf(new_det).getirrep()) s.push_back (Csf(m,n,SpinSpace(sp), sp, IrrepVector(sym.getirrep(),0))); } return s; }
bool plConvert::Convert(hsTArray<plMaxNode*>& nodes) { #ifndef HS_NO_TRY try #endif { fSettings->fReconvert = true; bool retVal = true; if (IOK()) retVal = ConvertList(nodes, &plMaxNode::ClearData, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::ConvertValidate, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::SetupPropertiesPass, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::PrepareSkin, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::MakeSceneObject, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::FirstComponentPass, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::MakeController, fpErrorMsg,fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::MakeCoordinateInterface, fpErrorMsg, fSettings);// must be before mesh if(IOK()) retVal = ConvertList(nodes, &plMaxNode::MakeParentOrRoomConnection, fpErrorMsg, fSettings); // after coord, before mesh (or any other pool data). // These shouldn't be opened until the components have had a chance to flag the MaxNodes plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap); hsVertexShader::Instance().Open(); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::MakeMesh, fpErrorMsg, fSettings); // must be before simulation if(IOK()) // doesn't matter when retVal = ConvertList(nodes, &plMaxNode::MakeLight, fpErrorMsg, fSettings); if(IOK()) // doesn't matter when retVal = ConvertList(nodes, &plMaxNode::MakeOccluder, fpErrorMsg, fSettings); if(IOK()) // must be after mesh retVal = ConvertList(nodes, &plMaxNode::MakeModifiers, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::ConvertComponents, fpErrorMsg, fSettings); if(IOK()) retVal = ConvertList(nodes, &plMaxNode::ShadeMesh, fpErrorMsg, fSettings); // These may be used by components, so don't close them till the end. plLightMapGen::Instance().Close(); hsVertexShader::Instance().Close(); plgDispatch::MsgSend(new plTransformMsg(nil, nil, nil, nil)); plgDispatch::MsgSend(new plDelayedTransformMsg(nil, nil, nil, nil)); DeInit(); return IOK(); } #ifndef HS_NO_TRY catch(plErrorMsg& err) { err.Show(); return false; } catch(...) { hsMessageBox("Unknown error during convert", "plConvert", hsMessageBoxNormal); return false; } #endif }
std::vector< SpinAdapted::Csf > SpinAdapted::Csf::distribute (const int n, const int sp, const IrrepVector &sym, const int left, const int right, const int edge, int integralIndex) { std::vector< Csf > s; int na = 0; int nb = 0; na = (n + sp) / 2; nb = (n - sp) / 2; if(dmrginp.hamiltonian() == HEISENBERG && nb != 0) return s; // let's count how many left and right orbitals there actually are int actualOrbs = dmrginp.spatial_to_spin()[right] - dmrginp.spatial_to_spin()[left]; int actualNA, actualNB; actualNA = actualOrbs/2; actualNB = actualOrbs/2; // cannot form this combination if (na > actualNA || nb > actualNB || na < 0 || nb < 0) { return s; } // now make orbital occupancies std::vector<int> abSeed (right-left); for (int i = 0; i < max(na, nb); ++i) abSeed [i] = -1; // okay now make some permutations (at most GUESS_PERMUTATIONS) std::vector< std::vector<int> > abList; abList.push_back (abSeed); int numberOfGuesses = dmrginp.guess_permutations(); bool doAgain = true; int numtries = 0; while(doAgain && numtries <500) { while (next_permutation (abSeed.begin (), abSeed.end ()) && numberOfGuesses--) abList.push_back (abSeed); // make list of available alpha and beta orbitals in energy ordering. std::vector<int> orbitalList; multimap <double, int> orbMap; int alphaIndex = 0; // scan orbitals from left to right, pick out orbitals which have smallest v_1(i, i) integrals for (int i=left; i<right; ++i) { if (dmrginp.hf_occupancy()[dmrginp.spatial_to_spin()[i]]) { orbitalList.push_back(alphaIndex); alphaIndex++; continue; } orbMap.insert(pair<double, int>(v_1[integralIndex](2*i, 2*i), alphaIndex)); ++alphaIndex; } for (multimap<double, int>::iterator m=orbMap.begin (); m!=orbMap.end (); ++m) orbitalList.push_back(m->second); // Now convert permutation lists to energy ordered form for (int i=0; i<abList.size (); ++i) ConvertList (abList[i], orbitalList); Slater last_det; // Now catenate to make Slaters for (int i=0; i<abList.size(); ++i) { std::vector<bool> lbuffer(dmrginp.spatial_to_spin()[left], 0); std::vector<bool> rbuffer(dmrginp.spatial_to_spin()[edge] - dmrginp.spatial_to_spin()[right], 0); std::vector<bool> orbs(dmrginp.spatial_to_spin()[right] - dmrginp.spatial_to_spin()[left], 0); int alphaI = 0; int betaI = 0; for (int orbI=0; orbI<(right-left); orbI++) { if (abList[i][alphaI]) { orbs[dmrginp.spatial_to_spin()[orbI]] = 1; if (betaI < min(na, nb)) { orbs[ dmrginp.spatial_to_spin()[orbI]+1] = 1; ++betaI; } } ++alphaI; } std::vector<bool> tmp = lbuffer; for (std::vector<bool>::iterator it = orbs.begin(); it!=orbs.end(); ++it) tmp.push_back(*it); for (std::vector<bool>::iterator it = rbuffer.begin(); it!=rbuffer.end(); ++it) tmp.push_back(*it); Slater new_det = Slater (Orbstring (tmp)); map<Slater, double> m; m[new_det] = 1.0; last_det = new_det; if(sym.getirrep() == AbelianSymmetryOf(new_det).getirrep()) s.push_back ( Csf(m, n, SpinSpace(sp), sp, IrrepVector(sym.getirrep(), 0)) ); } if (s.size() == 0) { numtries++; doAgain = true; abList.clear(); numberOfGuesses = dmrginp.guess_permutations(); } else doAgain = false; } return s; }