void FWSingle::fillWalkerPositionsandWeights(int nstep)
{
// int needed = walkersPerBlock[nstep] - W.getActiveWalkers();
// if (needed>0) W.createWalkers(needed);
// else if (needed<0) W.destroyWalkers(-1*needed-1);
vector<float> ALLcoordinates;
readInFloat(nstep,ALLcoordinates);
int nelectrons = W[0]->R.size();
int nfloats=OHMMS_DIM*nelectrons;
vector<float> SINGLEcoordinate(nfloats);
ForwardWalkingData fwer;
fwer.resize(nelectrons);
vector<float>::iterator fgg(ALLcoordinates.begin()), fgg2(ALLcoordinates.begin()+nfloats);
for(int nw=0; nw<W.getActiveWalkers(); nw++)
{
std::copy( fgg,fgg2,SINGLEcoordinate.begin());
fwer.fromFloat(SINGLEcoordinate);
W[nw]->R=fwer.Pos;
W[nw]->Weight = 1.0;
fgg+=nfloats;
fgg2+=nfloats;
}
}
bool FWSingle::run()
{
Estimators->start(weightLength,1);
fillIDMatrix();
//we do this once because we only want to link parents to parents if we need to
// if (verbose>1) app_log()<<" getting weights for generation "<<gensTransferred<<endl;
vector<vector<vector<int> > > WeightHistory;
WeightHistory.push_back(Weights);
for(int ill=1; ill<weightLength; ill++)
{
transferParentsOneGeneration();
FWOneStep();
WeightHistory.push_back(Weights);
}
if (verbose>0)
app_log()<<" Done Computing Weights"<<endl;
int nprops = H.sizeOfObservables();//local energy, local potnetial and all hamiltonian elements
int FirstHamiltonian = H.startIndex();
vector<vector<vector<RealType> > > savedValues;
int nelectrons = W[0]->R.size();
int nfloats=OHMMS_DIM*nelectrons;
ForwardWalkingData fwer;
fwer.resize(nelectrons);
// MCWalkerConfiguration* savedW = new MCWalkerConfiguration(W);
for(int step=0; step<numSteps; step++)
{
vector<float> ALLcoordinates;
readInFloat(step,ALLcoordinates);
vector<float> SINGLEcoordinate(nfloats);
vector<float>::iterator fgg(ALLcoordinates.begin()), fgg2(ALLcoordinates.begin()+nfloats);
W.resetCollectables();
vector<vector<RealType> > stepObservables;
for(int wstep=0; wstep<walkersPerBlock[step]; wstep++)
{
std::copy( fgg,fgg2,SINGLEcoordinate.begin());
fwer.fromFloat(SINGLEcoordinate);
W.R=fwer.Pos;
fgg+=nfloats;
fgg2+=nfloats;
W.update();
RealType logpsi(Psi.evaluateLog(W));
RealType eloc=H.evaluate( W );
// (*W[0]).resetProperty(logpsi,1,eloc);
H.auxHevaluate(W);
H.saveProperty(W.getPropertyBase());
vector<RealType> walkerObservables(nprops+2,0);
walkerObservables[0]= eloc;
walkerObservables[1]= H.getLocalPotential();
const RealType* restrict ePtr = W.getPropertyBase();
for(int i=0; i<nprops; i++)
walkerObservables[i+2] = ePtr[FirstHamiltonian+i] ;
stepObservables.push_back(walkerObservables);
}
savedValues.push_back(stepObservables);
}
for(int ill=0; ill<weightLength; ill++)
{
Estimators->startBlock(1);
Estimators->accumulate(savedValues,WeightHistory[ill],getNumberOfSamples(ill));
Estimators->stopBlock(getNumberOfSamples(ill));
}
Estimators->stop();
return true;
}
int main(const int argc, const char* const argv[]) {
//! undirected graphs with out-edges stored in lists and the vertices stored in a vector (to enable index-access)
typedef boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS, boost::property<boost::vertex_name_t, std::string> > UndirectedGraph;
typedef boost::graph_traits<UndirectedGraph>::vertex_descriptor vertex_type;
typedef boost::graph_traits<UndirectedGraph>::vertices_size_type vertices_size_type;
typedef boost::graph_traits<UndirectedGraph>::edges_size_type edges_size_type;
UndirectedGraph g;
{
boost::dynamic_properties p;
p.property("node_id", get(boost::vertex_name, g));
boost::read_graphviz(std::cin, g, p);
}
const vertices_size_type n = num_vertices(g);
const edges_size_type m = num_edges(g);
std::cout << "\n" << n << ", " << m << std::endl;
OKlib::HypergraphColouring::output_vertex_degrees(g, std::cout);
std::cout << std::endl;
OKlib::HypergraphColouring::Greedy_colouring<UndirectedGraph> fgg(g);
assert(fgg.n == n);
{
typedef std::map<std::string, vertex_type> name_map_type;
name_map_type map;
for (vertices_size_type i = 0; i < n; ++i)
map.insert(std::make_pair(get(boost::vertex_name, g, fgg.given_order[i]), fgg.given_order[i]));
assert(map.size() == n);
typedef name_map_type::const_iterator iterator;
const iterator end(map.end());
vertices_size_type i = 0;
for (iterator j(map.begin()); j != end; ++i, ++j)
fgg.running_order[i] = j -> second;
}
fgg.colouring();
std::cout << "lexicographical order = " << fgg.num_colours << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.running_order[i]) << " ";
std::cout << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.running_order[i]) << " -> " << fgg.colour_vec[get(boost::vertex_index, g, fgg.running_order[i])] << ", ";
std::cout << std::endl;
std::stable_sort(fgg.running_order.begin(), fgg.running_order.end(), fgg.sort);
fgg.colouring();
std::cout << "smallest degrees first = " << fgg.num_colours << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.running_order[i]) << " ";
std::cout << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.running_order[i]) << " -> " << fgg.colour_vec[get(boost::vertex_index, g, fgg.running_order[i])] << ", ";
std::cout << std::endl;
std::reverse(fgg.running_order.begin(), fgg.running_order.end());
fgg.colouring();
std::cout << "largest degrees first = " << fgg.num_colours << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.running_order[i]) << " ";
std::cout << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.running_order[i]) << " -> " << fgg.colour_vec[get(boost::vertex_index, g, fgg.running_order[i])] << ", ";
std::cout << std::endl;
if (argc > 1) {
fgg.evaluation();
std::cout << "\n";
for (vertices_size_type i = 0; i <= n; ++i)
std::cout << i << " : " << fgg.hash_orders[i] << "\n";
std::cout << std::endl;
std::cout << "min numbers of colours = " << fgg.min_colours << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.optimal_order[i]) << " ";
std::cout << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.optimal_order[i]) << " -> " << fgg.optimal_colouring[get(boost::vertex_index, g, fgg.optimal_order[i])] << ", ";
std::cout << std::endl;
std::cout << "max number of colours = " << fgg.max_colours << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.worst_order[i]) << " ";
std::cout << std::endl;
for (vertices_size_type i = 0; i < n; ++i)
std::cout << get(boost::vertex_name, g, fgg.worst_order[i]) << " -> " << fgg.worst_colouring[get(boost::vertex_index, g, fgg.worst_order[i])] << ", ";
std::cout << std::endl;
}
}
