qreal ellipticityOfASymmetricThreeByThreeMatrix(const Matrix<qreal,3,3> &A)
{
SelfAdjointEigenSolver<Matrix<qreal, 3, 3> > eigensolver(A);
Matrix<qreal, 3, 1> eigenvalues=eigensolver.eigenvalues();
return (eigenvalues(0) / eigenvalues(1)) - 1.0 ;
}
qint64 signatureOfASymmetricThreeByThreeMatrix(const Matrix<qreal,3,3> &A)
{
SelfAdjointEigenSolver<Matrix<qreal, 3, 3> > eigensolver(A);
Matrix<qreal,3,1> eigenvalues=eigensolver.eigenvalues();
return signOfARealNumber(eigenvalues(0)) +
signOfARealNumber(eigenvalues(1)) +
signOfARealNumber(eigenvalues(2));
}
EllipsoidSampler(LivePoints const& arg_live) :
EllipsoidFit(arg_live) {
n_dim = 2;
max_bound = sqrt(max_bound);
for(int ii=0; ii<n_dim; ii++){
eigenvalues(ii) = sqrt(eigenvalues(ii));
}
}
void phmc_compute_ev(const int trajectory_counter,
const double plaquette_energy) {
double atime, etime, temp=0., temp2=0.;
int max_iter_ev, no_eigenvalues;
char * phmcfilename = "phmc.data";
FILE * countfile;
#ifdef MPI
atime = MPI_Wtime();
#else
atime = (double)clock()/(double)(CLOCKS_PER_SEC);
#endif
max_iter_ev = 1000;
g_mu = g_mu1;
if((g_proc_id == 0) && (g_debug_level > 0)) {
printf("# Computing eigenvalues for heavy doublet\n");
}
no_eigenvalues = 1;
if(g_epsbar!=0.0)
temp = eigenvalues_bi(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 0);
else
temp = eigenvalues(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 0, 0, nstore, even_odd_flag);
no_eigenvalues = 1;
if(g_epsbar!=0.0)
temp2 = eigenvalues_bi(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 1);
else
temp2 = eigenvalues(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 1, 0, nstore, even_odd_flag);
if((g_proc_id == 0) && (g_debug_level > 0)) {
printf("# PHMC: lowest eigenvalue end of trajectory %d = %e\n",
trajectory_counter, temp);
printf("# PHMC: maximal eigenvalue end of trajectory %d = %e\n",
trajectory_counter, temp2);
}
if(g_proc_id == 0) {
countfile = fopen(phmcfilename, "a");
fprintf(countfile, "%d %1.12f %1.5e %1.5e %1.5e %1.5e\n",
trajectory_counter, plaquette_energy/(6.*VOLUME*g_nproc), temp, temp2, stilde_min, stilde_max);
fclose(countfile);
}
#ifdef MPI
etime = MPI_Wtime();
#else
etime = (double)clock()/(double)(CLOCKS_PER_SEC);
#endif
if((g_proc_id == 0)) {
printf("# PHMC: time/s for eigenvalue computation %e\n", etime-atime);
}
}
bool eigen(const Mat2& M, Vec2& evals, Vec2 evecs[2])
{
bool result = eigenvalues(M, evals);
if( result )
eigenvectors(M, evals, evecs);
return result;
}
// }}}
void CheckUnfolded() { // {{{
std::clog << "Esta rutina toca que tenga la lindea donde digo ... hist.update(eigenvalues);... "
<< "en el loop. Ahora la comento porque se enchocha haciendo la optimizacion -O2"
<< std::endl ;
int dim=40, ElementsEnsemble=1000;
#ifdef ASK
std::clog << "Inserte dim ";
cin >> dim;
std::cout <<std::endl ;
std::clog << "Inserte ElementsEnsemble ";
cin >> ElementsEnsemble;
std::cout <<std::endl ;
#endif
std::clog << "dim="<<dim<<" ElementsEnsemble="<<ElementsEnsemble<<std::endl ;
itpp::cmat H;
itpp::Vec<double> eigenvalues(dim);
itpp::Histogram<double> hist(-0.5*dim+0.5, 0.5*dim-.5, dim);
for (int i=0; i<ElementsEnsemble; i++) {
FlatSpectrumGUE(eigenvalues);
// hist.update(eigenvalues);
}
std::cout << hist.get_bins() - ElementsEnsemble <<std::endl ;
std::cout << "los elementos deben ser muy chicos con respecto a "
<<ElementsEnsemble<<std::endl ;
} // }}}
/*
* Prints the eigenvalues to a file named by given argument.
*
* @param filename The name of the outputfile, full name.
*/
void JacobiRotationProblem :: saveResult(string filename) {
if (!isFinished()) {
cout << "Tried to print result when solver hasn't run." << endl;
return;
}
ofstream outfile;
outfile.open(filename.c_str());
vec eigenvalues = matrix.diag();
eigenvalues = sort(eigenvalues);
// Write header with metadata
if (hasParams) {
outfile << "******[META]******" << endl;
outfile << "#e: " << numElectrons << endl;
outfile << "rhoMax: " << rhoMax << endl;
outfile << "n: " << matrix.n_rows << endl;
if (numElectrons > 1) {
outfile << "omegaR: " << omegaR << endl;
}
outfile << "***[SORTED EIGENVALUES]***" << endl;
}
for (int i = 0; i < matrix.n_rows; i++) {
outfile << eigenvalues(i) << endl;
}
outfile.close();
cout << "Saved eigenvalues to file: " << filename << endl;
}
// }}}
itpp::Mat<std::complex<double> > RandomGUE(int const dim, std::string normalization="sigma_offdiag=1", double const percentage_away=0.1){ //{{{
if (normalization=="sigma_offdiag=1"){
return RandomGUEDeltaOne(dim);
}
else if (normalization=="unfolded mean_level_spacing=1"){
itpp::Mat<std::complex<double> > U(dim, dim), tmp(dim,dim);
itpp::Vec<std::complex<double> > vec1(dim);
itpp::Vec<double> eigenvalues(dim);
FlatSpectrumGUE(U, eigenvalues);
for (int i=0; i<dim; i++){
vec1=itpp::elem_mult(conj(U.get_col(i)), to_cvec(eigenvalues));
for (int j=i; j<dim; j++){
tmp(i,j)=vec1*U.get_col(j);
if (i<j){tmp(j,i)=conj(tmp(i,j));}
}
}
return tmp;
// std::cout << eigenvalues << std::endl ;
// ya dentro de temp tenemos a una matriz que no esta
// unfolded. tengo que encontrar los eigenvectores,
// luego los eigenvalores, eso diagonalizarlos y chan
} else {
std::cerr << "Illegal normalization RandomGUE" << percentage_away;
exit(1);
}
// Aca poner un factor de normalizacion opcional
}
// }}}
itpp::Mat<std::complex<double> > RandomCUE(int const dim){ //{{{
itpp::Mat<std::complex<double> > U(dim,dim);
itpp::Vec<double> eigenvalues(dim);
FlatSpectrumGUE(U, eigenvalues);
// return exp( 2*itpp::pi*std::complex<double>(0.,1.)* itpp:randu())*U;
return exp(2.*itpp::pi*std::complex<double>(0.,1.) *itpp::randu() )*U;
}
/**
* Create a system of size 9-by-9 with known eigenvalues and compare it with the eigenvalues computed from the QR method implemented in ViennaCL.
**/
int main()
{
// Change to 'double' if supported by your hardware.
typedef float ScalarType;
std::cout << "Testing matrix of size " << 9 << "-by-" << 9 << std::endl;
viennacl::matrix<ScalarType> A_input(9,9);
viennacl::matrix<ScalarType> Q(9, 9);
std::vector<ScalarType> eigenvalues_ref(9);
std::vector<ScalarType> eigenvalues(9);
viennacl::vector<ScalarType> vcl_eigenvalues(9);
initialize(A_input, eigenvalues_ref);
std::cout << std::endl <<"Input matrix: " << std::endl;
std::cout << A_input << std::endl;
viennacl::matrix<ScalarType> A_input2(A_input); // duplicate to demonstrate the use with both std::vector and viennacl::vector
/**
* Call the function qr_method_sym() to calculate eigenvalues and eigenvectors
* Parameters:
* - A_input - input matrix to find eigenvalues and eigenvectors from
* - Q - matrix, where the calculated eigenvectors will be stored in
* - eigenvalues - vector, where the calculated eigenvalues will be stored in
**/
std::cout << "Calculation..." << std::endl;
viennacl::linalg::qr_method_sym(A_input, Q, eigenvalues);
/**
* Same as before, but writing the eigenvalues to a ViennaCL-vector:
**/
viennacl::linalg::qr_method_sym(A_input2, Q, vcl_eigenvalues);
/**
* Print the computed eigenvalues and eigenvectors:
**/
std::cout << std::endl << "Eigenvalues with std::vector<T>:" << std::endl;
vector_print(eigenvalues);
std::cout << "Eigenvalues with viennacl::vector<T>: " << std::endl << vcl_eigenvalues << std::endl;
std::cout << std::endl << "Reference eigenvalues:" << std::endl;
vector_print(eigenvalues_ref);
std::cout << std::endl;
std::cout << "Eigenvectors - each column is an eigenvector" << std::endl;
std::cout << Q << std::endl;
/**
* That's it. Print a success message and exit.
**/
std::cout << std::endl;
std::cout << "------- Tutorial completed --------" << std::endl;
std::cout << std::endl;
return EXIT_SUCCESS;
}
MinimumError MnPosDef::operator()(const MinimumError& e, const MnMachinePrecision& prec) const {
MnAlgebraicSymMatrix err(e.invHessian());
if(err.size() == 1 && err(0,0) < prec.eps()) {
err(0,0) = 1.;
return MinimumError(err, MinimumError::MnMadePosDef());
}
if(err.size() == 1 && err(0,0) > prec.eps()) {
return e;
}
// std::cout<<"MnPosDef init matrix= "<<err<<std::endl;
double epspdf = std::max(1.e-6, prec.eps2());
double dgmin = err(0,0);
for(unsigned int i = 0; i < err.nrow(); i++) {
if(err(i,i) < prec.eps2()) //std::cout<<"negative or zero diagonal element "<<i<<" in covariance matrix"<<std::endl;
if(err(i,i) < dgmin) dgmin = err(i,i);
}
double dg = 0.;
if(dgmin < prec.eps2()) {
//dg = 1. + epspdf - dgmin;
dg = 0.5 + epspdf - dgmin;
// dg = 0.5*(1. + epspdf - dgmin);
//std::cout<<"added "<<dg<<" to diagonal of error matrix"<<std::endl;
//std::cout << "Error matrix " << err << std::endl;
}
MnAlgebraicVector s(err.nrow());
MnAlgebraicSymMatrix p(err.nrow());
for(unsigned int i = 0; i < err.nrow(); i++) {
err(i,i) += dg;
if(err(i,i) < 0.) err(i,i) = 1.;
s(i) = 1./sqrt(err(i,i));
for(unsigned int j = 0; j <= i; j++) {
p(i,j) = err(i,j)*s(i)*s(j);
}
}
//std::cout<<"MnPosDef p: "<<p<<std::endl;
MnAlgebraicVector eval = eigenvalues(p);
double pmin = eval(0);
double pmax = eval(eval.size() - 1);
//std::cout<<"pmin= "<<pmin<<" pmax= "<<pmax<<std::endl;
pmax = std::max(fabs(pmax), 1.);
if(pmin > epspdf*pmax) return MinimumError(err, e.dcovar());
double padd = 0.001*pmax - pmin;
//std::cout<<"eigenvalues: "<<std::endl;
for(unsigned int i = 0; i < err.nrow(); i++) {
err(i,i) *= (1. + padd);
//std::cout<<eval(i)<<std::endl;
}
// std::cout<<"MnPosDef final matrix: "<<err<<std::endl;
// std::cout<<"matrix forced pos-def by adding "<<padd<<" to diagonal"<<std::endl;
// std::cout<<"eigenvalues: "<<eval<<std::endl;
return MinimumError(err, MinimumError::MnMadePosDef());
}
//Write Results for source shape to binary file
void write_sourceshape_bin(const char* prefix, const int config,
const int tslice, const int nb_ev, const std::vector<std::pair<double,double> >& results) {
//build filename
char filename[200];
sprintf(filename, "%s_nev%d.%04d.%03d.bin", prefix, nb_ev, config, tslice);
std::ofstream eigenvalues(filename, std::ofstream::binary);
eigenvalues.write(reinterpret_cast<const char*>(&results[0]),
results.size()*sizeof(std::pair<double,double>));
eigenvalues.close();
}
int
IncrementalIntegrator::addModalDampingForce(void)
{
int res = 0;
if (modalDampingValues == 0)
return 0;
int numModes = modalDampingValues->Size();
const Vector &eigenvalues = theAnalysisModel->getEigenvalues();
if (eigenvalues.Size() < numModes)
numModes = eigenvalues.Size();
Vector dampingForces(theSOE->getNumEqn());
dampingForces.Zero();
for (int i=0; i<numModes; i++) {
DOF_GrpIter &theDOFs1 = theAnalysisModel->getDOFs();
DOF_Group *dofPtr;
double beta = 0.0;
double eigenvalue = eigenvalues(i); // theEigenSOE->getEigenvalue(i+1);
double wn = 0.;
if (eigenvalue > 0)
wn = sqrt(eigenvalue);
while ((dofPtr = theDOFs1()) != 0) {
beta += dofPtr->getDampingBetaFactor(i, (*modalDampingValues)(i), wn);
}
DOF_GrpIter &theDOFs2 = theAnalysisModel->getDOFs();
while ((dofPtr = theDOFs2()) != 0) {
if (theSOE->addB(dofPtr->getDampingBetaForce(i, beta),dofPtr->getID()) <0) {
opserr << "WARNING IncrementalIntegrator::failed in dofPtr";
res = -1;
}
}
}
return res;
}
/**
* Exactly calculates the eigenvalues of the matrix.
* Needs lapack.
* @param calc_eigenvectors set to true to calculate the eigenvectors. The hamiltonian
* matrix is then overwritten by the vectors.
* @return the vector of the sorted eigenvalues
*/
std::vector<double> MomHamiltonian::ExactDiagonalizeFull(bool calc_eigenvectors)
{
std::vector<double> eigenvalues(dim);
int offset = 0;
for(int B=0; B<L; B++)
{
int dim = mombase[B].size();
Diagonalize(dim, blockmat[B].get(), &eigenvalues[offset], calc_eigenvectors);
offset += dim;
}
std::sort(eigenvalues.begin(), eigenvalues.end());
return eigenvalues;
}
inline
double
SymmetricPositiveDefiniteEigenDecomposition<MatrixType>::conditionNo()
const {
const RealVectorType& ev = eigenvalues();
double numerator = ev(ev.size() - 1);
double denominator = ev(0);
// All eigenvalues of a positive semi-definite matrix are
// non-negative, so in theory no need to take absolute values.
// Unfortunately, numerical instabilities can cause eigenvalues to
// be slightly negative. We should interprete that as 0.
if (denominator < 0)
denominator = 0;
return numerator <= 0 ? std::numeric_limits<double>::infinity()
: numerator / denominator;
}
// }}}
itpp::Vec<double> FlatSpectrumGUE(int const dim, double const percen_out=0.2){ //{{{
int extra_per_side=itpp::round_i(std::ceil(0.5*percen_out*dim));
int dim_large=itpp::round_i(std::ceil(dim+2*extra_per_side));
itpp::Mat<std::complex<double> > temp(dim_large,dim_large);
itpp::Vec<double> eigenvalues(dim);
itpp::Vec<double> eigenvalues_enlarged(dim_large);
// eigenvalues.set_size(dim_enlarged);
temp=RandomGUEDeltaOne(dim_large);
itpp::eig_sym(temp, eigenvalues_enlarged);
eigenvalues_enlarged /= sqrt(4*dim_large);
if (eigenvalues_enlarged(extra_per_side)<-1 ||
eigenvalues_enlarged(dim+extra_per_side-1)> 1){
std::cout<<"UUps, we need to a bigger part of the "
<<" spectrum in routine FlatSpectrumGUE";
exit(1);
}
unfoldcircular(eigenvalues_enlarged);
eigenvalues=eigenvalues_enlarged.get(extra_per_side,
dim+extra_per_side-1);
return eigenvalues;
}
inline
void
EigenTypes<MapOptions>
::SymmetricPositiveDefiniteEigenDecomposition<MatrixType>::computeExtras(
const MatrixType &inMatrix, int inExtras) {
if (inExtras & ComputePseudoInverse) {
mPinv.resize(inMatrix.rows(), inMatrix.cols());
// FIXME: No hard-coded constant here
if (conditionNo() < 1000) {
// We are doing a Cholesky decomposition of a matrix with
// pivoting. This is faster than the PartialPivLU that
// Eigen's inverse() method would use
mPinv = inMatrix.template selfadjointView<Eigen::Lower>().ldlt()
.solve(MatrixType::Identity(inMatrix.rows(), inMatrix.cols()));
} else {
if (!Base::m_eigenvectorsOk)
Base::compute(inMatrix, Eigen::ComputeEigenvectors);
const RealVectorType& ev = eigenvalues();
// The eigenvalue are sorted in increasing order
Scalar epsilon = inMatrix.rows()
* ev(ev.size() - 1)
* std::numeric_limits<Scalar>::epsilon();
RealVectorType eigenvectorsInverted(ev.size());
for (Index i = 0; i < static_cast<Index>(ev.size()); ++i) {
eigenvectorsInverted(i) = ev(i) < epsilon
? Scalar(0)
: Scalar(1) / ev(i);
}
mPinv = Base::eigenvectors()
* eigenvectorsInverted.asDiagonal()
* Base::eigenvectors().transpose();
}
}
}
//once eigenvalues are obtained, the remaining is to solve a linear system
CplxMatrix CplxMatrix::eigenvectors() const{
CplxMatrix eigenVal;
eigenVal.chop(PRECISION);
eigenVal = eigenvalues();
int degree = eigenVal.r;
CplxMatrix result(c, degree);
for (int i = 0; i < result.c; i++) {
CplxMatrix temp(r,c+1);
for (int k = 0; k < r; k++) {
for (int j = 0; j < c; j++) {
temp.el(k,j) = el(k,j);
}
}
for (int k = 0; k < r; k++) {
temp.el(k, k) = temp.el(k, k) - eigenVal.el(i, 0);
}
temp = temp.SolveLinearSystem();
for (int j = 0; j < result.r; j++) {
result.el(j,i) = temp.el(j, temp.c-2);
}
}
return result;
}
bool ElevationMap::fuse(const grid_map::Index& topLeftIndex, const grid_map::Index& size)
{
ROS_DEBUG("Fusing elevation map...");
// Nothing to do.
if ((size == 0).any()) return false;
// Initializations.
const ros::WallTime methodStartTime(ros::WallTime::now());
boost::recursive_mutex::scoped_lock scopedLock(fusedMapMutex_);
// Copy raw elevation map data for safe multi-threading.
boost::recursive_mutex::scoped_lock scopedLockForRawData(rawMapMutex_);
auto rawMapCopy = rawMap_;
scopedLockForRawData.unlock();
// More initializations.
const double halfResolution = fusedMap_.getResolution() / 2.0;
const float minimalWeight = std::numeric_limits<float>::epsilon() * (float) 2.0;
// Conservative cell inclusion for ellipse iterator.
const double ellipseExtension = M_SQRT2 * fusedMap_.getResolution();
// Check if there is the need to reset out-dated data.
if (fusedMap_.getTimestamp() != rawMapCopy.getTimestamp()) resetFusedData();
// Align fused map with raw map.
if (rawMapCopy.getPosition() != fusedMap_.getPosition()) fusedMap_.move(rawMapCopy.getPosition());
// For each cell in requested area.
for (SubmapIterator areaIterator(rawMapCopy, topLeftIndex, size); !areaIterator.isPastEnd(); ++areaIterator) {
// Check if fusion for this cell has already been done earlier.
if (fusedMap_.isValid(*areaIterator)) continue;
if (!rawMapCopy.isValid(*areaIterator)) {
// This is an empty cell (hole in the map).
// TODO.
continue;
}
// Get size of error ellipse.
const float& sigmaXsquare = rawMapCopy.at("horizontal_variance_x", *areaIterator);
const float& sigmaYsquare = rawMapCopy.at("horizontal_variance_y", *areaIterator);
const float& sigmaXYsquare = rawMapCopy.at("horizontal_variance_xy", *areaIterator);
Eigen::Matrix2d covarianceMatrix;
covarianceMatrix << sigmaXsquare, sigmaXYsquare, sigmaXYsquare, sigmaYsquare;
// 95.45% confidence ellipse which is 2.486-sigma for 2 dof problem.
// http://www.reid.ai/2012/09/chi-squared-distribution-table-with.html
const double uncertaintyFactor = 2.486; // sqrt(6.18)
Eigen::EigenSolver<Eigen::Matrix2d> solver(covarianceMatrix);
Eigen::Array2d eigenvalues(solver.eigenvalues().real().cwiseAbs());
Eigen::Array2d::Index maxEigenvalueIndex;
eigenvalues.maxCoeff(&maxEigenvalueIndex);
Eigen::Array2d::Index minEigenvalueIndex;
maxEigenvalueIndex == Eigen::Array2d::Index(0) ? minEigenvalueIndex = 1 : minEigenvalueIndex = 0;
const Length ellipseLength = 2.0 * uncertaintyFactor * Length(eigenvalues(maxEigenvalueIndex), eigenvalues(minEigenvalueIndex)).sqrt() + ellipseExtension;
const double ellipseRotation(atan2(solver.eigenvectors().col(maxEigenvalueIndex).real()(1), solver.eigenvectors().col(maxEigenvalueIndex).real()(0)));
// Requested length and position (center) of submap in map.
Position requestedSubmapPosition;
rawMapCopy.getPosition(*areaIterator, requestedSubmapPosition);
EllipseIterator ellipseIterator(rawMapCopy, requestedSubmapPosition, ellipseLength, ellipseRotation);
// Prepare data fusion.
Eigen::ArrayXf means, weights;
const unsigned int maxNumberOfCellsToFuse = ellipseIterator.getSubmapSize().prod();
means.resize(maxNumberOfCellsToFuse);
weights.resize(maxNumberOfCellsToFuse);
WeightedEmpiricalCumulativeDistributionFunction<float> lowerBoundDistribution;
WeightedEmpiricalCumulativeDistributionFunction<float> upperBoundDistribution;
float maxStandardDeviation = sqrt(eigenvalues(maxEigenvalueIndex));
float minStandardDeviation = sqrt(eigenvalues(minEigenvalueIndex));
Eigen::Rotation2Dd rotationMatrix(ellipseRotation);
std::string maxEigenvalueLayer, minEigenvalueLayer;
if (maxEigenvalueIndex == 0) {
maxEigenvalueLayer = "horizontal_variance_x";
minEigenvalueLayer = "horizontal_variance_y";
} else {
maxEigenvalueLayer = "horizontal_variance_y";
minEigenvalueLayer = "horizontal_variance_x";
}
// For each cell in error ellipse.
size_t i = 0;
for (; !ellipseIterator.isPastEnd(); ++ellipseIterator) {
if (!rawMapCopy.isValid(*ellipseIterator)) {
// Empty cell in submap (cannot be center cell because we checked above).
continue;
}
means[i] = rawMapCopy.at("elevation", *ellipseIterator);
// Compute weight from probability.
Position absolutePosition;
rawMapCopy.getPosition(*ellipseIterator, absolutePosition);
Eigen::Vector2d distanceToCenter = (rotationMatrix * (absolutePosition - requestedSubmapPosition)).cwiseAbs();
float probability1 =
cumulativeDistributionFunction(distanceToCenter.x() + halfResolution, 0.0, maxStandardDeviation)
- cumulativeDistributionFunction(distanceToCenter.x() - halfResolution, 0.0, maxStandardDeviation);
float probability2 =
cumulativeDistributionFunction(distanceToCenter.y() + halfResolution, 0.0, minStandardDeviation)
- cumulativeDistributionFunction(distanceToCenter.y() - halfResolution, 0.0, minStandardDeviation);
const float weight = max(minimalWeight, probability1 * probability2);
weights[i] = weight;
const float standardDeviation = sqrt(rawMapCopy.at("variance", *ellipseIterator));
lowerBoundDistribution.add(means[i] - 2.0 * standardDeviation, weight);
upperBoundDistribution.add(means[i] + 2.0 * standardDeviation, weight);
i++;
}
if (i == 0) {
// Nothing to fuse.
fusedMap_.at("elevation", *areaIterator) = rawMapCopy.at("elevation", *areaIterator);
fusedMap_.at("lower_bound", *areaIterator) = rawMapCopy.at("elevation", *areaIterator) - 2.0 * sqrt(rawMapCopy.at("variance", *areaIterator));
fusedMap_.at("upper_bound", *areaIterator) = rawMapCopy.at("elevation", *areaIterator) + 2.0 * sqrt(rawMapCopy.at("variance", *areaIterator));
fusedMap_.at("color", *areaIterator) = rawMapCopy.at("color", *areaIterator);
continue;
}
// Fuse.
means.conservativeResize(i);
weights.conservativeResize(i);
float mean = (weights * means).sum() / weights.sum();
if (!std::isfinite(mean)) {
ROS_ERROR("Something went wrong when fusing the map: Mean = %f", mean);
continue;
}
// Add to fused map.
fusedMap_.at("elevation", *areaIterator) = mean;
lowerBoundDistribution.compute();
upperBoundDistribution.compute();
fusedMap_.at("lower_bound", *areaIterator) = lowerBoundDistribution.quantile(0.01); // TODO
fusedMap_.at("upper_bound", *areaIterator) = upperBoundDistribution.quantile(0.99); // TODO
// TODO Add fusion of colors.
fusedMap_.at("color", *areaIterator) = rawMapCopy.at("color", *areaIterator);
}
fusedMap_.setTimestamp(rawMapCopy.getTimestamp());
const ros::WallDuration duration(ros::WallTime::now() - methodStartTime);
ROS_INFO("Elevation map has been fused in %f s.", duration.toSec());
return true;
}
void pclbo::LBOEstimation<PointT, NormalT>::compute() {
typename pcl::KdTreeFLANN<PointT>::Ptr kdt(new pcl::KdTreeFLANN<PointT>());
kdt->setInputCloud(_cloud);
const double avg_dist = pclbo::avg_distance<PointT>(10, _cloud, kdt);
const double h = 5 * avg_dist;
std::cout << "Average distance between points: " << avg_dist << std::endl;
int points_with_mass = 0;
double avg_mass = 0.0;
B.resize(_cloud->size());
std::cout << "Computing the Mass matrix..." << std::flush;
// Compute the mass matrix diagonal B
for (int i = 0; i < _cloud->size(); i++) {
const auto& point = _cloud->at(i);
const auto& normal = _normals->at(i);
const auto& normal_vector = normal.getNormalVector3fMap().template cast<double>();
if (!pcl::isFinite(point)) continue;
std::vector<int> indices;
std::vector<float> distances;
kdt->radiusSearch(point, h, indices, distances);
if (indices.size() < 4) {
B[i] = 0.0;
continue;
}
// Project the neighbor points in the tangent plane at p_i with normal n_i
std::vector<Eigen::Vector3d> projected_points;
for (const auto& neighbor_index : indices) {
if (neighbor_index != i) {
const auto& neighbor_point = _cloud->at(neighbor_index);
projected_points.push_back(project(point, normal, neighbor_point));
}
}
assert(projected_points.size() >= 3);
// Use the first vector to create a 2D basis
Eigen::Vector3d u = projected_points[0];
u.normalize();
Eigen::Vector3d v = (u.cross(normal_vector));
v.normalize();
// Add the points to a 2D plane
std::vector<Eigen::Vector2d> plane;
// Add the point at the center
plane.push_back(Eigen::Vector2d::Zero());
// Add the rest of the points
for (const auto& projected : projected_points) {
double x = projected.dot(u);
double y = projected.dot(v);
// Add the 2D point to the vector
plane.push_back(Eigen::Vector2d(x, y));
}
assert(plane.size() >= 4);
// Compute the voronoi cell area of the point
double area = VoronoiDiagram::area(plane);
B[i] = area;
avg_mass += area;
points_with_mass++;
}
// Average mass
if (points_with_mass > 0) {
avg_mass /= static_cast<double>(points_with_mass);
}
// Set border points to have average mass
for (auto& b : B) {
if (b == 0.0) {
b = avg_mass;
}
}
std::cout << "done" << std::endl;
std::cout << "Computing the stiffness matrix..." << std::flush;
std::vector<double> diag(_cloud->size(), 0.0);
// Compute the stiffness matrix Q
for (int i = 0; i < _cloud->size(); i++) {
const auto& point = _cloud->at(i);
if (!pcl::isFinite(point)) continue;
std::vector<int> indices;
std::vector<float> distances;
kdt->radiusSearch(point, h, indices, distances);
for (const auto& j : indices) {
if (j != i) {
const auto& neighbor = _cloud->at(j);
double d = (neighbor.getVector3fMap() - point.getVector3fMap()).norm();
double w = B[i] * B[j] * (1.0 / (4.0 * M_PI * h * h)) * exp(-(d * d) / (4.0 * h));
I.push_back(i);
J.push_back(j);
S.push_back(w);
diag[i] += w;
}
}
}
// Fill the diagonal as the negative sum of the rows
for (int i = 0; i < diag.size(); i++) {
I.push_back(i);
J.push_back(i);
S.push_back(-diag[i]);
}
// Compute the B^{-1}Q matrix
Eigen::MatrixXd Q = Eigen::MatrixXd::Zero(_cloud->size(), _cloud->size());
for (int i = 0; i < I.size(); i++) {
const int row = I[i];
const int col = J[i];
Q(row, col) = S[i];
}
std::cout << "done" << std::endl;
std::cout << "Computing eigenvectors" << std::endl;
Eigen::Map<Eigen::VectorXd> B_vec(B.data(), B.size());
Eigen::GeneralizedSelfAdjointEigenSolver<Eigen::MatrixXd> ges;
ges.compute(Q, B_vec.asDiagonal());
eigenvalues = ges.eigenvalues();
eigenfunctions = ges.eigenvectors();
// Sort the eigenvalues by magnitude
std::vector<std::pair<double, int> > map_vector(eigenvalues.size());
for (auto i = 0; i < eigenvalues.size(); i++) {
map_vector[i].first = std::abs(eigenvalues(i));
map_vector[i].second = i;
}
std::sort(map_vector.begin(), map_vector.end());
// truncate the first 100 eigenfunctions
Eigen::MatrixXd eigenvectors(eigenfunctions.rows(), eigenfunctions.cols());
Eigen::VectorXd eigenvals(eigenfunctions.cols());
eigenvalues.resize(map_vector.size());
for (auto i = 0; i < map_vector.size(); i++) {
const auto& pair = map_vector[i];
eigenvectors.col(i) = eigenfunctions.col(pair.second);
eigenvals(i) = pair.first;
}
eigenfunctions = eigenvectors;
eigenvalues = eigenvals;
}
void op_invert(const int op_id, const int index_start, const int write_prop) {
operator * optr = &operator_list[op_id];
double atime = 0., etime = 0., nrm1 = 0., nrm2 = 0.;
int i;
optr->iterations = 0;
optr->reached_prec = -1.;
g_kappa = optr->kappa;
boundary(g_kappa);
atime = gettime();
if(optr->type == TMWILSON || optr->type == WILSON || optr->type == CLOVER) {
g_mu = optr->mu;
g_c_sw = optr->c_sw;
if(optr->type == CLOVER) {
if (g_cart_id == 0 && g_debug_level > 1) {
printf("#\n# csw = %e, computing clover leafs\n", g_c_sw);
}
init_sw_fields(VOLUME);
sw_term( (const su3**) g_gauge_field, optr->kappa, optr->c_sw);
/* this must be EE here! */
/* to match clover_inv in Qsw_psi */
sw_invert(EE, optr->mu);
}
for(i = 0; i < 2; i++) {
if (g_cart_id == 0) {
printf("#\n# 2 kappa mu = %e, kappa = %e, c_sw = %e\n", g_mu, g_kappa, g_c_sw);
}
if(optr->type != CLOVER) {
if(use_preconditioning){
g_precWS=(void*)optr->precWS;
}
else {
g_precWS=NULL;
}
optr->iterations = invert_eo( optr->prop0, optr->prop1, optr->sr0, optr->sr1,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec,
0, optr->even_odd_flag,optr->no_extra_masses, optr->extra_masses, optr->id );
/* check result */
M_full(g_spinor_field[4], g_spinor_field[5], optr->prop0, optr->prop1);
}
else {
optr->iterations = invert_clover_eo(optr->prop0, optr->prop1, optr->sr0, optr->sr1,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec,
&g_gauge_field, &Qsw_pm_psi, &Qsw_minus_psi);
/* check result */
Msw_full(g_spinor_field[4], g_spinor_field[5], optr->prop0, optr->prop1);
}
diff(g_spinor_field[4], g_spinor_field[4], optr->sr0, VOLUME / 2);
diff(g_spinor_field[5], g_spinor_field[5], optr->sr1, VOLUME / 2);
nrm1 = square_norm(g_spinor_field[4], VOLUME / 2, 1);
nrm2 = square_norm(g_spinor_field[5], VOLUME / 2, 1);
optr->reached_prec = nrm1 + nrm2;
/* convert to standard normalisation */
/* we have to mult. by 2*kappa */
if (optr->kappa != 0.) {
mul_r(optr->prop0, (2*optr->kappa), optr->prop0, VOLUME / 2);
mul_r(optr->prop1, (2*optr->kappa), optr->prop1, VOLUME / 2);
}
if (optr->solver != CGMMS && write_prop) /* CGMMS handles its own I/O */
optr->write_prop(op_id, index_start, i);
if(optr->DownProp) {
optr->mu = -optr->mu;
} else
break;
}
}
else if(optr->type == DBTMWILSON || optr->type == DBCLOVER) {
g_mubar = optr->mubar;
g_epsbar = optr->epsbar;
g_c_sw = 0.;
if(optr->type == DBCLOVER) {
g_c_sw = optr->c_sw;
if (g_cart_id == 0 && g_debug_level > 1) {
printf("#\n# csw = %e, computing clover leafs\n", g_c_sw);
}
init_sw_fields(VOLUME);
sw_term( (const su3**) g_gauge_field, optr->kappa, optr->c_sw);
sw_invert_nd(optr->mubar*optr->mubar-optr->epsbar*optr->epsbar);
}
for(i = 0; i < SourceInfo.no_flavours; i++) {
if(optr->type != DBCLOVER) {
optr->iterations = invert_doublet_eo( optr->prop0, optr->prop1, optr->prop2, optr->prop3,
optr->sr0, optr->sr1, optr->sr2, optr->sr3,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec);
}
else {
optr->iterations = invert_cloverdoublet_eo( optr->prop0, optr->prop1, optr->prop2, optr->prop3,
optr->sr0, optr->sr1, optr->sr2, optr->sr3,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec);
}
g_mu = optr->mubar;
if(optr->type != DBCLOVER) {
M_full(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+2], optr->prop0, optr->prop1);
}
else {
Msw_full(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+2], optr->prop0, optr->prop1);
}
assign_add_mul_r(g_spinor_field[DUM_DERI+1], optr->prop2, -optr->epsbar, VOLUME/2);
assign_add_mul_r(g_spinor_field[DUM_DERI+2], optr->prop3, -optr->epsbar, VOLUME/2);
g_mu = -g_mu;
if(optr->type != DBCLOVER) {
M_full(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+4], optr->prop2, optr->prop3);
}
else {
Msw_full(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+4], optr->prop2, optr->prop3);
}
assign_add_mul_r(g_spinor_field[DUM_DERI+3], optr->prop0, -optr->epsbar, VOLUME/2);
assign_add_mul_r(g_spinor_field[DUM_DERI+4], optr->prop1, -optr->epsbar, VOLUME/2);
diff(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+1], optr->sr0, VOLUME/2);
diff(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+2], optr->sr1, VOLUME/2);
diff(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+3], optr->sr2, VOLUME/2);
diff(g_spinor_field[DUM_DERI+4], g_spinor_field[DUM_DERI+4], optr->sr3, VOLUME/2);
nrm1 = square_norm(g_spinor_field[DUM_DERI+1], VOLUME/2, 1);
nrm1 += square_norm(g_spinor_field[DUM_DERI+2], VOLUME/2, 1);
nrm1 += square_norm(g_spinor_field[DUM_DERI+3], VOLUME/2, 1);
nrm1 += square_norm(g_spinor_field[DUM_DERI+4], VOLUME/2, 1);
optr->reached_prec = nrm1;
g_mu = g_mu1;
/* For standard normalisation */
/* we have to mult. by 2*kappa */
mul_r(g_spinor_field[DUM_DERI], (2*optr->kappa), optr->prop0, VOLUME/2);
mul_r(g_spinor_field[DUM_DERI+1], (2*optr->kappa), optr->prop1, VOLUME/2);
mul_r(g_spinor_field[DUM_DERI+2], (2*optr->kappa), optr->prop2, VOLUME/2);
mul_r(g_spinor_field[DUM_DERI+3], (2*optr->kappa), optr->prop3, VOLUME/2);
/* the final result should be stored in the convention used in */
/* hep-lat/0606011 */
/* this requires multiplication of source with */
/* (1+itau_2)/sqrt(2) and the result with (1-itau_2)/sqrt(2) */
mul_one_pm_itau2(optr->prop0, optr->prop2, g_spinor_field[DUM_DERI],
g_spinor_field[DUM_DERI+2], -1., VOLUME/2);
mul_one_pm_itau2(optr->prop1, optr->prop3, g_spinor_field[DUM_DERI+1],
g_spinor_field[DUM_DERI+3], -1., VOLUME/2);
/* write propagator */
if(write_prop) optr->write_prop(op_id, index_start, i);
mul_r(optr->prop0, 1./(2*optr->kappa), g_spinor_field[DUM_DERI], VOLUME/2);
mul_r(optr->prop1, 1./(2*optr->kappa), g_spinor_field[DUM_DERI+1], VOLUME/2);
mul_r(optr->prop2, 1./(2*optr->kappa), g_spinor_field[DUM_DERI+2], VOLUME/2);
mul_r(optr->prop3, 1./(2*optr->kappa), g_spinor_field[DUM_DERI+3], VOLUME/2);
/* mirror source, but not for volume sources */
if(i == 0 && SourceInfo.no_flavours == 2 && SourceInfo.type != 1) {
if (g_cart_id == 0) {
fprintf(stdout, "# Inversion done in %d iterations, squared residue = %e!\n",
optr->iterations, optr->reached_prec);
}
mul_one_pm_itau2(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+2], optr->sr0, optr->sr2, -1., VOLUME/2);
mul_one_pm_itau2(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+3], optr->sr1, optr->sr3, -1., VOLUME/2);
mul_one_pm_itau2(optr->sr0, optr->sr2, g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI], +1., VOLUME/2);
mul_one_pm_itau2(optr->sr1, optr->sr3, g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+1], +1., VOLUME/2);
}
/* volume sources need only one inversion */
else if(SourceInfo.type == 1) i++;
}
}
else if(optr->type == OVERLAP) {
g_mu = 0.;
m_ov=optr->m;
eigenvalues(&optr->no_ev, 5000, optr->ev_prec, 0, optr->ev_readwrite, nstore, optr->even_odd_flag);
/* ov_check_locality(); */
/* index_jd(&optr->no_ev_index, 5000, 1.e-12, optr->conf_input, nstore, 4); */
ov_n_cheby=optr->deg_poly;
if(use_preconditioning==1)
g_precWS=(void*)optr->precWS;
else
g_precWS=NULL;
if(g_debug_level > 3) ov_check_ginsparg_wilson_relation_strong();
invert_overlap(op_id, index_start);
if(write_prop) optr->write_prop(op_id, index_start, 0);
}
etime = gettime();
if (g_cart_id == 0 && g_debug_level > 0) {
fprintf(stdout, "# Inversion done in %d iterations, squared residue = %e!\n",
optr->iterations, optr->reached_prec);
fprintf(stdout, "# Inversion done in %1.2e sec. \n", etime - atime);
}
return;
}
/**
* Description not yet available.
* \param
*/
void laplace_approximation_calculator::
do_newton_raphson_banded(function_minimizer * pfmin,double f_from_1,
int& no_converge_flag)
{
//quadratic_prior * tmpptr=quadratic_prior::ptr[0];
//cout << tmpptr << endl;
laplace_approximation_calculator::where_are_we_flag=2;
double maxg=fabs(evaluate_function(uhat,pfmin));
laplace_approximation_calculator::where_are_we_flag=0;
dvector uhat_old(1,usize);
for(int ii=1;ii<=num_nr_iters;ii++)
{
// test newton raphson
switch(hesstype)
{
case 3:
bHess->initialize();
break;
case 4:
Hess.initialize();
break;
default:
cerr << "Illegal value for hesstype here" << endl;
ad_exit(1);
}
grad.initialize();
//int check=initial_params::stddev_scale(scale,uhat);
//check=initial_params::stddev_curvscale(curv,uhat);
//max_separable_g=0.0;
sparse_count = 0;
step=get_newton_raphson_info_banded(pfmin);
//if (bHess)
// cout << "norm(*bHess) = " << norm(*bHess) << endl;
//cout << "norm(Hess) = " << norm(Hess) << endl;
//cout << grad << endl;
//check_pool_depths();
if (!initial_params::mc_phase)
cout << "Newton raphson " << ii << " ";
if (quadratic_prior::get_num_quadratic_prior()>0)
{
quadratic_prior::get_cHessian_contribution(Hess,xsize);
quadratic_prior::get_cgradient_contribution(grad,xsize);
}
int ierr=0;
if (hesstype==3)
{
if (use_dd_nr==0)
{
banded_lower_triangular_dmatrix bltd=choleski_decomp(*bHess,ierr);
if (ierr && no_converge_flag ==0)
{
no_converge_flag=1;
//break;
}
if (ierr)
{
double oldval;
evaluate_function(oldval,uhat,pfmin);
uhat=banded_calculations_trust_region_approach(uhat,pfmin);
}
else
{
if (dd_nr_flag==0)
{
dvector v=solve(bltd,grad);
step=-solve_trans(bltd,v);
//uhat_old=uhat;
uhat+=step;
}
else
{
#if defined(USE_DD_STUFF)
int n=grad.indexmax();
maxg=fabs(evaluate_function(uhat,pfmin));
uhat=dd_newton_raphson2(grad,*bHess,uhat);
#else
cerr << "high precision Newton Raphson not implemented" << endl;
ad_exit(1);
#endif
}
maxg=fabs(evaluate_function(uhat,pfmin));
if (f_from_1< pfmin->lapprox->fmc1.fbest)
{
uhat=banded_calculations_trust_region_approach(uhat,pfmin);
maxg=fabs(evaluate_function(uhat,pfmin));
}
}
}
else
{
cout << "error not used" << endl;
ad_exit(1);
/*
banded_symmetric_ddmatrix bHessdd=banded_symmetric_ddmatrix(*bHess);
ddvector gradd=ddvector(grad);
//banded_lower_triangular_ddmatrix bltdd=choleski_decomp(bHessdd,ierr);
if (ierr && no_converge_flag ==0)
{
no_converge_flag=1;
break;
}
if (ierr)
{
double oldval;
evaluate_function(oldval,uhat,pfmin);
uhat=banded_calculations_trust_region_approach(uhat,pfmin);
maxg=fabs(evaluate_function(uhat,pfmin));
}
else
{
ddvector v=solve(bHessdd,gradd);
step=-make_dvector(v);
//uhat_old=uhat;
uhat=make_dvector(ddvector(uhat)+step);
maxg=fabs(evaluate_function(uhat,pfmin));
if (f_from_1< pfmin->lapprox->fmc1.fbest)
{
uhat=banded_calculations_trust_region_approach(uhat,pfmin);
maxg=fabs(evaluate_function(uhat,pfmin));
}
}
*/
}
if (maxg < 1.e-13)
{
break;
}
}
else if (hesstype==4)
{
dvector step;
# if defined(USE_ATLAS)
if (!ad_comm::no_atlas_flag)
{
step=-atlas_solve_spd(Hess,grad,ierr);
}
else
{
dmatrix A=choleski_decomp_positive(Hess,ierr);
if (!ierr)
{
step=-solve(Hess,grad);
//step=-solve(A*trans(A),grad);
}
}
if (!ierr) break;
# else
if (sparse_hessian_flag)
{
//step=-solve(*sparse_triplet,Hess,grad,*sparse_symbolic);
dvector temp=solve(*sparse_triplet2,grad,*sparse_symbolic2,ierr);
if (ierr)
{
step=-temp;
}
else
{
cerr << "matrix not pos definite in sparse choleski" << endl;
pfmin->bad_step_flag=1;
int on;
int nopt;
if ((on=option_match(ad_comm::argc,ad_comm::argv,"-ieigvec",nopt))
>-1)
{
dmatrix M=make_dmatrix(*sparse_triplet2);
ofstream ofs3("inner-eigvectors");
ofs3 << "eigenvalues and eigenvectors " << endl;
dvector v=eigenvalues(M);
dmatrix ev=trans(eigenvectors(M));
ofs3 << "eigenvectors" << endl;
int i;
for (i=1;i<=ev.indexmax();i++)
{
ofs3 << setw(4) << i << " "
<< setshowpoint() << setw(14) << setprecision(10) << v(i)
<< " "
<< setshowpoint() << setw(14) << setprecision(10)
<< ev(i) << endl;
}
}
}
//cout << norm2(step-tmpstep) << endl;
//dvector step1=-solve(Hess,grad);
//cout << norm2(step-step1) << endl;
}
else
{
step=-solve(Hess,grad);
}
# endif
if (pmin->bad_step_flag)
break;
uhat_old=uhat;
uhat+=step;
double maxg_old=maxg;
maxg=fabs(evaluate_function(uhat,pfmin));
if (maxg>maxg_old)
{
uhat=uhat_old;
evaluate_function(uhat,pfmin);
break;
}
if (maxg < 1.e-13)
{
break;
}
}
if (sparse_hessian_flag==0)
{
for (int i=1;i<=usize;i++)
{
y(i+xsize)=uhat(i);
}
}
else
{
for (int i=1;i<=usize;i++)
{
value(y(i+xsize))=uhat(i);
}
}
}
}
itpp::vec FlatSpectrumGSE(int d){ // {{{
itpp::vec eigenvalues(d);
FlatSpectrumGSE(eigenvalues);
return eigenvalues;
}
void function_minimizer::sd_routine(void)
{
int nvar=initial_params::nvarcalc(); // get the number of active parameters
dvector x(1,nvar);
initial_params::xinit(x); // get the number of active parameters
initial_params::restore_start_phase();
int nvar1=initial_params::nvarcalc(); // get the number of active parameters
int num_sdrep_types=stddev_params::num_stddev_params +
initial_params::num_active_calc();
param_labels.allocate(1,num_sdrep_types);
param_size.allocate(1,num_sdrep_types);
int ii=1;
size_t max_name_length = 0;
for (int i=0;i<initial_params::num_initial_params;i++)
{
//if ((initial_params::varsptr[i])->phase_start
// <= initial_params::current_phase)
if (withinbound(0,(initial_params::varsptr[i])->phase_start,
initial_params::current_phase))
{
param_labels[ii]=
(initial_params::varsptr[i])->label();
param_size[ii]=
(initial_params::varsptr[i])->size_count();
if (max_name_length<param_labels[ii].size())
{
max_name_length=param_labels[ii].size();
}
ii++;
}
}
int start_stdlabels=ii;
for (int i=0;i< stddev_params::num_stddev_params;i++)
{
param_labels[ii]=
stddev_params::stddevptr[i]->label();
param_size[ii]=
stddev_params::stddevptr[i]->size_count();
if (max_name_length<param_labels[ii].size())
{
max_name_length=param_labels[ii].size();
}
ii++;
}
int end_stdlabels=ii-1;
int ndvar=stddev_params::num_stddev_calc();
dvector scale(1,nvar1); // need to get scale from somewhere
dvector v(1,nvar); // need to read in v from model.rep
dmatrix S(1,nvar,1,nvar);
{
uistream cif("admodel.cov");
int tmp_nvar = 0;
cif >> tmp_nvar;
if (nvar !=tmp_nvar)
{
cerr << "Incorrect number of independent variables in file"
" model.cov" << endl;
exit(1);
}
cif >> S;
if (!cif)
{
cerr << "error reading covariance matrix from model.cov" << endl;
exit(1);
}
}
int sgn;
initial_params::stddev_scale(scale,x);
double lndet=-ln_det(S,sgn)-2.0*sum(log(scale));
initial_params::set_active_random_effects();
//int nvar1=initial_params::nvarcalc();
dvector diag(1,nvar1+ndvar);
dvector tmp(1,nvar1+ndvar);
{
ofstream ofs("admodel.tmp");
#if defined(__GNU__) || defined(DOS386) || defined(__GNUDOS__)
// *******************************************************
// *******************************************************
{
if (nvar==nvar1) // no random effects
{
for (int i=1;i<=nvar;i++)
{
for (int j=1;j<=i;j++)
{
tmp(j)=S(i,j)*scale(i)*scale(j);
ofs << tmp(j) << " ";
}
ofs << endl;
diag(i)=tmp(i);
}
dmatrix tv(1,ndvar,1,nvar1);
adstring tmpstring="admodel.dep";
if (ad_comm::wd_flag)
tmpstring = ad_comm::adprogram_name + ".dep";
cifstream cif((char*)tmpstring);
int tmp_nvar = 0, tmp_ndvar = 0;
cif >> tmp_nvar >> tmp_ndvar;
if (tmp_nvar!=nvar1)
{
cerr << " tmp_nvar != nvar1 in file " << tmpstring
<< endl;
ad_exit(1);
}
if (ndvar>0)
{
cif >> tv;
dvector tmpsub(1,nvar);
for (int i=1;i<=ndvar;i++)
{
for (int j=1;j<=nvar;j++)
{
tmpsub(j)=(tv(i)*S(j))*scale(j);
}
ofs << tmpsub << " ";
tmpsub=tv(i)*S;
for (int j=1;j<=i;j++)
{
tmp(nvar+j)=tmpsub*tv(j);
ofs << tmp(nvar+j) << " ";
}
diag(i+nvar)=tmp(i+nvar);
if (diag(i+nvar)<=0.0)
{
cerr << "Estimated covariance matrix may not"
" be positive definite" << endl;
cerr << sort(eigenvalues(S)) << endl;
}
ofs << endl;
}
}
}
else // have random effects
{
dmatrix tv(1,ndvar,1,nvar1);
adstring tmpstring="admodel.dep";
if (ad_comm::wd_flag)
tmpstring = ad_comm::adprogram_name + ".dep";
cifstream cif((char*)tmpstring);
int tmp_nvar = 0, tmp_ndvar = 0;
cif >> tmp_nvar >> tmp_ndvar;
if (tmp_nvar!=nvar1)
{
cerr << " tmp_nvar != nvar1 in file " << tmpstring
<< endl;
ad_exit(1);
}
dmatrix BS(1,nvar1,1,nvar1);
BS.initialize();
get_bigS(ndvar,nvar1,nvar,S,BS,scale);
{
tmpstring = ad_comm::adprogram_name + ".bgs";
uostream uos((char*)(tmpstring));
if (!uos)
{
cerr << "error opening file " << tmpstring << endl;
ad_exit(1);
}
uos << nvar1;
uos << BS;
if (!uos)
{
cerr << "error writing to file " << tmpstring << endl;
ad_exit(1);
}
}
for (int i=1;i<=nvar1;i++)
{
for (int j=1;j<=i;j++)
{
tmp(j)=BS(i,j)*scale(i)*scale(j);
ofs << tmp(j) << " ";
}
ofs << endl;
diag(i)=tmp(i);
}
if (ndvar>0)
{
cif >> tv;
dvector tmpsub(1,nvar1);
for (int i=1;i<=ndvar;i++)
{
for (int j=1;j<=nvar1;j++)
{
tmpsub(j)=(tv(i)*BS(j))*scale(j);
}
ofs << tmpsub << " ";
tmpsub=tv(i)*BS;
for (int j=1;j<=i;j++)
{
tmp(nvar1+j)=tmpsub*tv(j);
ofs << tmp(nvar1+j) << " ";
}
diag(i+nvar1)=tmp(i+nvar1);
if (diag(i+nvar1)<=0.0)
{
if (norm(tv(i))>1.e-100)
{
cerr << "Estimated covariance matrix may not"
" be positive definite" << endl;
cerr << sort(eigenvalues(BS)) << endl;
}
}
ofs << endl;
}
}
}
int main(int argc,char *argv[]) {
FILE *parameterfile=NULL;
int c, j, is=0, ic=0;
int x, X, y, Y, z, Z, t, tt, i, sum;
char * filename = NULL;
char datafilename[50];
char parameterfilename[50];
char conf_filename[50];
char * input_filename = NULL;
double plaquette_energy, nrm;
double * norm;
struct stout_parameters params_smear;
#ifdef _GAUGE_COPY
int kb=0;
#endif
#ifdef MPI
double atime=0., etime=0.;
#endif
#ifdef _KOJAK_INST
#pragma pomp inst init
#pragma pomp inst begin(main)
#endif
DUM_DERI = 6;
/* DUM_DERI + 2 is enough (not 7) */
DUM_SOLVER = DUM_DERI+2;
DUM_MATRIX = DUM_SOLVER+6;
/* DUM_MATRIX + 2 is enough (not 6) */
NO_OF_SPINORFIELDS = DUM_MATRIX+2;
verbose = 0;
g_use_clover_flag = 0;
g_nr_of_psf = 1;
#ifdef MPI
MPI_Init(&argc, &argv);
#endif
while ((c = getopt(argc, argv, "h?f:o:")) != -1) {
switch (c) {
case 'f':
input_filename = calloc(200, sizeof(char));
strcpy(input_filename,optarg);
break;
case 'o':
filename = calloc(200, sizeof(char));
strcpy(filename,optarg);
break;
case 'h':
case '?':
default:
usage();
break;
}
}
if(input_filename == NULL){
input_filename = "hmc.input";
}
if(filename == NULL){
filename = "output";
}
/* Read the input file */
read_input(input_filename);
/* here we want no even/odd preconditioning */
even_odd_flag = 0;
/* this DBW2 stuff is not needed for the inversion ! */
g_rgi_C1 = 0;
if(Nsave == 0){
Nsave = 1;
}
tmlqcd_mpi_init(argc, argv);
g_dbw2rand = 0;
#ifndef MPI
g_dbw2rand = 0;
#endif
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND, 0);
#endif
if ( j!= 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(-1);
}
j = init_geometry_indices(VOLUMEPLUSRAND);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for geometry indices! Aborting...\n");
exit(-1);
}
if(even_odd_flag) {
j = init_spinor_field(VOLUMEPLUSRAND/2, NO_OF_SPINORFIELDS);
}
else {
j = init_spinor_field(VOLUMEPLUSRAND, NO_OF_SPINORFIELDS);
}
if ( j!= 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(-1);
}
g_mu = g_mu1;
if(g_proc_id == 0){
/*construct the filenames for the observables and the parameters*/
strcpy(datafilename,filename); strcat(datafilename,".data");
strcpy(parameterfilename,filename); strcat(parameterfilename,".para");
parameterfile=fopen(parameterfilename, "w");
write_first_messages(parameterfile, 0, 1);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary();
#ifdef _USE_HALFSPINOR
j = init_dirac_halfspinor();
if ( j!= 0) {
fprintf(stderr, "Not enough memory for halffield! Aborting...\n");
exit(-1);
}
if(g_sloppy_precision_flag == 1) {
j = init_dirac_halfspinor32();
if ( j!= 0) {
fprintf(stderr, "Not enough memory for 32-Bit halffield! Aborting...\n");
exit(-1);
}
}
# if (defined _PERSISTENT)
init_xchange_halffield();
# endif
#endif
norm = (double*)calloc(3.*LX/2.+T/2., sizeof(double));
for(j=0;j<Nmeas; j++) {
sprintf(conf_filename,"%s.%.4d", gauge_input_filename, nstore);
if (g_proc_id == 0){
printf("Reading Gauge field from file %s\n", conf_filename); fflush(stdout);
}
read_lime_gauge_field(conf_filename);
if (g_proc_id == 0){
printf("done!\n"); fflush(stdout);
}
#ifdef MPI
xchange_gauge();
#endif
#ifdef _GAUGE_COPY
update_backward_gauge();
#endif
/* Compute minimal eigenvalues, if wanted */
if(compute_evs != 0) {
eigenvalues(&no_eigenvalues, 1000, eigenvalue_precision, 0, compute_evs, nstore, even_odd_flag);
}
/*compute the energy of the gauge field*/
plaquette_energy = measure_gauge_action();
if(g_proc_id == 0) {
printf("The plaquette value is %e\n", plaquette_energy/(6.*VOLUME*g_nproc)); fflush(stdout);
}
if (use_stout_flag == 1){
params_smear.rho = stout_rho;
params_smear.iterations = stout_no_iter;
if (stout_smear((su3_tuple*)(g_gauge_field[0]), ¶ms_smear, (su3_tuple*)(g_gauge_field[0])) != 0)
exit(1) ;
g_update_gauge_copy = 1;
g_update_gauge_energy = 1;
g_update_rectangle_energy = 1;
plaquette_energy = measure_gauge_action();
if (g_proc_id == 0) {
printf("# The plaquette value after stouting is %e\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
}
source_spinor_field(g_spinor_field[0], g_spinor_field[1], 0, 0);
convert_eo_to_lexic(g_spinor_field[DUM_DERI], g_spinor_field[0], g_spinor_field[1]);
D_psi(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI]);
if(even_odd_flag) {
i = invert_eo(g_spinor_field[2], g_spinor_field[3], g_spinor_field[0], g_spinor_field[1],
solver_precision, max_solver_iterations, solver_flag, g_relative_precision_flag,
sub_evs_cg_flag, even_odd_flag);
convert_eo_to_lexic(g_spinor_field[DUM_DERI+1], g_spinor_field[2], g_spinor_field[3]);
}
for(i = 0; i < 3*LX/2+T/2; i++){
norm[i] = 0.;
}
for(x = 0; x < LX; x++){
if(x > LX/2) X = LX-x;
else X = x;
for(y = 0; y < LY; y++){
if(y > LY/2) Y = LY-y;
else Y = y;
for(z = 0; z < LZ; z++){
if(z > LZ/2) Z = LZ-z;
else Z = z;
for(t = 0; t < T; t++){
if(t > T/2) tt = T - t;
else tt = t;
sum = X + Y + Z + tt;
_spinor_norm_sq(nrm, g_spinor_field[DUM_DERI+1][ g_ipt[t][x][y][z] ]);
/* _spinor_norm_sq(nrm, qprop[0][0][1][ g_ipt[t][x][y][z] ]); */
printf("%e %e\n", g_spinor_field[DUM_DERI+1][ g_ipt[t][x][y][z] ].s0.c0.re, g_spinor_field[DUM_DERI+1][ g_ipt[t][x][y][z] ].s0.c0.im);
nrm = sqrt( nrm );
printf("%1.12e\n", nrm);
if(nrm > norm[sum]) norm[sum] = nrm;
}
}
}
}
for(i = 0; i < 3*L/2+T/2; i++){
printf("%d %1.12e\n", i, norm[i]);
}
printf("\n");
nstore+=Nsave;
}
#ifdef MPI
MPI_Finalize();
#endif
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_moment_field();
return(0);
#ifdef _KOJAK_INST
#pragma pomp inst end(main)
#endif
}
int main(int argc, char *argv[])
{
FILE *parameterfile = NULL;
int c, j, i, ix = 0, isample = 0, op_id = 0;
char * filename = NULL;
char datafilename[50];
char parameterfilename[50];
char conf_filename[50];
char * input_filename = NULL;
double plaquette_energy;
struct stout_parameters params_smear;
spinor **s, *s_;
#ifdef _KOJAK_INST
#pragma pomp inst init
#pragma pomp inst begin(main)
#endif
#if (defined SSE || defined SSE2 || SSE3)
signal(SIGILL, &catch_ill_inst);
#endif
DUM_DERI = 8;
DUM_MATRIX = DUM_DERI + 5;
#if ((defined BGL && defined XLC) || defined _USE_TSPLITPAR)
NO_OF_SPINORFIELDS = DUM_MATRIX + 3;
#else
NO_OF_SPINORFIELDS = DUM_MATRIX + 3;
#endif
verbose = 0;
g_use_clover_flag = 0;
#ifdef MPI
# ifdef OMP
int mpi_thread_provided;
MPI_Init_thread(&argc, &argv, MPI_THREAD_SERIALIZED, &mpi_thread_provided);
# else
MPI_Init(&argc, &argv);
# endif
MPI_Comm_rank(MPI_COMM_WORLD, &g_proc_id);
#else
g_proc_id = 0;
#endif
while ((c = getopt(argc, argv, "h?vVf:o:")) != -1) {
switch (c) {
case 'f':
input_filename = calloc(200, sizeof(char));
strcpy(input_filename, optarg);
break;
case 'o':
filename = calloc(200, sizeof(char));
strcpy(filename, optarg);
break;
case 'v':
verbose = 1;
break;
case 'V':
fprintf(stdout,"%s %s\n",PACKAGE_STRING,git_hash);
exit(0);
break;
case 'h':
case '?':
default:
usage();
break;
}
}
if (input_filename == NULL) {
input_filename = "invert.input";
}
if (filename == NULL) {
filename = "output";
}
/* Read the input file */
if( (j = read_input(input_filename)) != 0) {
fprintf(stderr, "Could not find input file: %s\nAborting...\n", input_filename);
exit(-1);
}
#ifdef OMP
if(omp_num_threads > 0)
{
omp_set_num_threads(omp_num_threads);
}
else {
if( g_proc_id == 0 )
printf("# No value provided for OmpNumThreads, running in single-threaded mode!\n");
omp_num_threads = 1;
omp_set_num_threads(omp_num_threads);
}
init_omp_accumulators(omp_num_threads);
#endif
/* this DBW2 stuff is not needed for the inversion ! */
if (g_dflgcr_flag == 1) {
even_odd_flag = 0;
}
g_rgi_C1 = 0;
if (Nsave == 0) {
Nsave = 1;
}
if (g_running_phmc) {
NO_OF_SPINORFIELDS = DUM_MATRIX + 8;
}
tmlqcd_mpi_init(argc, argv);
g_dbw2rand = 0;
/* starts the single and double precision random number */
/* generator */
start_ranlux(rlxd_level, random_seed);
/* we need to make sure that we don't have even_odd_flag = 1 */
/* if any of the operators doesn't use it */
/* in this way even/odd can still be used by other operators */
for(j = 0; j < no_operators; j++) if(!operator_list[j].even_odd_flag) even_odd_flag = 0;
#ifndef MPI
g_dbw2rand = 0;
#endif
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND, 0);
#endif
if (j != 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(-1);
}
j = init_geometry_indices(VOLUMEPLUSRAND);
if (j != 0) {
fprintf(stderr, "Not enough memory for geometry indices! Aborting...\n");
exit(-1);
}
if (no_monomials > 0) {
if (even_odd_flag) {
j = init_monomials(VOLUMEPLUSRAND / 2, even_odd_flag);
}
else {
j = init_monomials(VOLUMEPLUSRAND, even_odd_flag);
}
if (j != 0) {
fprintf(stderr, "Not enough memory for monomial pseudo fermion fields! Aborting...\n");
exit(-1);
}
}
if (even_odd_flag) {
j = init_spinor_field(VOLUMEPLUSRAND / 2, NO_OF_SPINORFIELDS);
}
else {
j = init_spinor_field(VOLUMEPLUSRAND, NO_OF_SPINORFIELDS);
}
if (j != 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(-1);
}
if (g_running_phmc) {
j = init_chi_spinor_field(VOLUMEPLUSRAND / 2, 20);
if (j != 0) {
fprintf(stderr, "Not enough memory for PHMC Chi fields! Aborting...\n");
exit(-1);
}
}
g_mu = g_mu1;
if (g_cart_id == 0) {
/*construct the filenames for the observables and the parameters*/
strcpy(datafilename, filename);
strcat(datafilename, ".data");
strcpy(parameterfilename, filename);
strcat(parameterfilename, ".para");
parameterfile = fopen(parameterfilename, "w");
write_first_messages(parameterfile, 1);
fclose(parameterfile);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary(g_kappa);
phmc_invmaxev = 1.;
init_operators();
/* this could be maybe moved to init_operators */
#ifdef _USE_HALFSPINOR
j = init_dirac_halfspinor();
if (j != 0) {
fprintf(stderr, "Not enough memory for halffield! Aborting...\n");
exit(-1);
}
if (g_sloppy_precision_flag == 1) {
j = init_dirac_halfspinor32();
if (j != 0)
{
fprintf(stderr, "Not enough memory for 32-bit halffield! Aborting...\n");
exit(-1);
}
}
# if (defined _PERSISTENT)
if (even_odd_flag)
init_xchange_halffield();
# endif
#endif
for (j = 0; j < Nmeas; j++) {
sprintf(conf_filename, "%s.%.4d", gauge_input_filename, nstore);
if (g_cart_id == 0) {
printf("#\n# Trying to read gauge field from file %s in %s precision.\n",
conf_filename, (gauge_precision_read_flag == 32 ? "single" : "double"));
fflush(stdout);
}
if( (i = read_gauge_field(conf_filename)) !=0) {
fprintf(stderr, "Error %d while reading gauge field from %s\n Aborting...\n", i, conf_filename);
exit(-2);
}
if (g_cart_id == 0) {
printf("# Finished reading gauge field.\n");
fflush(stdout);
}
#ifdef MPI
xchange_gauge(g_gauge_field);
#endif
/*compute the energy of the gauge field*/
plaquette_energy = measure_gauge_action( (const su3**) g_gauge_field);
if (g_cart_id == 0) {
printf("# The computed plaquette value is %e.\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
if (use_stout_flag == 1){
params_smear.rho = stout_rho;
params_smear.iterations = stout_no_iter;
/* if (stout_smear((su3_tuple*)(g_gauge_field[0]), ¶ms_smear, (su3_tuple*)(g_gauge_field[0])) != 0) */
/* exit(1) ; */
g_update_gauge_copy = 1;
g_update_gauge_energy = 1;
g_update_rectangle_energy = 1;
plaquette_energy = measure_gauge_action( (const su3**) g_gauge_field);
if (g_cart_id == 0) {
printf("# The plaquette value after stouting is %e\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
}
if (reweighting_flag == 1) {
reweighting_factor(reweighting_samples, nstore);
}
/* Compute minimal eigenvalues, if wanted */
if (compute_evs != 0) {
eigenvalues(&no_eigenvalues, 5000, eigenvalue_precision,
0, compute_evs, nstore, even_odd_flag);
}
if (phmc_compute_evs != 0) {
#ifdef MPI
MPI_Finalize();
#endif
return(0);
}
/* Compute the mode number or topological susceptibility using spectral projectors, if wanted*/
if(compute_modenumber != 0 || compute_topsus !=0){
s_ = calloc(no_sources_z2*VOLUMEPLUSRAND+1, sizeof(spinor));
s = calloc(no_sources_z2, sizeof(spinor*));
if(s_ == NULL) {
printf("Not enough memory in %s: %d",__FILE__,__LINE__); exit(42);
}
if(s == NULL) {
printf("Not enough memory in %s: %d",__FILE__,__LINE__); exit(42);
}
for(i = 0; i < no_sources_z2; i++) {
#if (defined SSE3 || defined SSE2 || defined SSE)
s[i] = (spinor*)(((unsigned long int)(s_)+ALIGN_BASE)&~ALIGN_BASE)+i*VOLUMEPLUSRAND;
#else
s[i] = s_+i*VOLUMEPLUSRAND;
#endif
z2_random_spinor_field(s[i], VOLUME);
/* what is this here needed for?? */
/* spinor *aux_,*aux; */
/* #if ( defined SSE || defined SSE2 || defined SSE3 ) */
/* aux_=calloc(VOLUMEPLUSRAND+1, sizeof(spinor)); */
/* aux = (spinor *)(((unsigned long int)(aux_)+ALIGN_BASE)&~ALIGN_BASE); */
/* #else */
/* aux_=calloc(VOLUMEPLUSRAND, sizeof(spinor)); */
/* aux = aux_; */
/* #endif */
if(g_proc_id == 0) {
printf("source %d \n", i);
}
if(compute_modenumber != 0){
mode_number(s[i], mstarsq);
}
if(compute_topsus !=0) {
top_sus(s[i], mstarsq);
}
}
free(s);
free(s_);
}
/* move to operators as well */
if (g_dflgcr_flag == 1) {
/* set up deflation blocks */
init_blocks(nblocks_t, nblocks_x, nblocks_y, nblocks_z);
/* the can stay here for now, but later we probably need */
/* something like init_dfl_solver called somewhere else */
/* create set of approximate lowest eigenvectors ("global deflation subspace") */
/* g_mu = 0.; */
/* boundary(0.125); */
generate_dfl_subspace(g_N_s, VOLUME);
/* boundary(g_kappa); */
/* g_mu = g_mu1; */
/* Compute little Dirac operators */
/* alt_block_compute_little_D(); */
if (g_debug_level > 0) {
check_projectors();
check_local_D();
}
if (g_debug_level > 1) {
check_little_D_inversion();
}
}
if(SourceInfo.type == 1) {
index_start = 0;
index_end = 1;
}
g_precWS=NULL;
if(use_preconditioning == 1){
/* todo load fftw wisdom */
#if (defined HAVE_FFTW ) && !( defined MPI)
loadFFTWWisdom(g_spinor_field[0],g_spinor_field[1],T,LX);
#else
use_preconditioning=0;
#endif
}
if (g_cart_id == 0) {
fprintf(stdout, "#\n"); /*Indicate starting of the operator part*/
}
for(op_id = 0; op_id < no_operators; op_id++) {
boundary(operator_list[op_id].kappa);
g_kappa = operator_list[op_id].kappa;
g_mu = 0.;
if(use_preconditioning==1 && PRECWSOPERATORSELECT[operator_list[op_id].solver]!=PRECWS_NO ){
printf("# Using preconditioning with treelevel preconditioning operator: %s \n",
precWSOpToString(PRECWSOPERATORSELECT[operator_list[op_id].solver]));
/* initial preconditioning workspace */
operator_list[op_id].precWS=(spinorPrecWS*)malloc(sizeof(spinorPrecWS));
spinorPrecWS_Init(operator_list[op_id].precWS,
operator_list[op_id].kappa,
operator_list[op_id].mu/2./operator_list[op_id].kappa,
-(0.5/operator_list[op_id].kappa-4.),
PRECWSOPERATORSELECT[operator_list[op_id].solver]);
g_precWS = operator_list[op_id].precWS;
if(PRECWSOPERATORSELECT[operator_list[op_id].solver] == PRECWS_D_DAGGER_D) {
fitPrecParams(op_id);
}
}
for(isample = 0; isample < no_samples; isample++) {
for (ix = index_start; ix < index_end; ix++) {
if (g_cart_id == 0) {
fprintf(stdout, "#\n"); /*Indicate starting of new index*/
}
/* we use g_spinor_field[0-7] for sources and props for the moment */
/* 0-3 in case of 1 flavour */
/* 0-7 in case of 2 flavours */
prepare_source(nstore, isample, ix, op_id, read_source_flag, source_location);
operator_list[op_id].inverter(op_id, index_start);
}
}
if(use_preconditioning==1 && operator_list[op_id].precWS!=NULL ){
/* free preconditioning workspace */
spinorPrecWS_Free(operator_list[op_id].precWS);
free(operator_list[op_id].precWS);
}
if(operator_list[op_id].type == OVERLAP){
free_Dov_WS();
}
}
nstore += Nsave;
}
#ifdef MPI
MPI_Finalize();
#endif
#ifdef OMP
free_omp_accumulators();
#endif
free_blocks();
free_dfl_subspace();
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_moment_field();
free_chi_spinor_field();
return(0);
#ifdef _KOJAK_INST
#pragma pomp inst end(main)
#endif
}
/**
Symmetrize and invert the hessian
*/
void function_minimizer::hess_inv(void)
{
initial_params::set_inactive_only_random_effects();
int nvar=initial_params::nvarcalc(); // get the number of active parameters
independent_variables x(1,nvar);
initial_params::xinit(x); // get the initial values into the x vector
//double f;
dmatrix hess(1,nvar,1,nvar);
uistream ifs("admodel.hes");
int file_nvar = 0;
ifs >> file_nvar;
if (nvar != file_nvar)
{
cerr << "Number of active variables in file mod_hess.rpt is wrong"
<< endl;
}
for (int i = 1;i <= nvar; i++)
{
ifs >> hess(i);
if (!ifs)
{
cerr << "Error reading line " << i << " of the hessian"
<< " in routine hess_inv()" << endl;
exit(1);
}
}
int hybflag = 0;
ifs >> hybflag;
dvector sscale(1,nvar);
ifs >> sscale;
if (!ifs)
{
cerr << "Error reading sscale"
<< " in routine hess_inv()" << endl;
}
double maxerr=0.0;
for (int i = 1;i <= nvar; i++)
{
for (int j=1;j<i;j++)
{
double tmp=(hess(i,j)+hess(j,i))/2.;
double tmp1=fabs(hess(i,j)-hess(j,i));
tmp1/=(1.e-4+fabs(hess(i,j))+fabs(hess(j,i)));
if (tmp1>maxerr) maxerr=tmp1;
hess(i,j)=tmp;
hess(j,i)=tmp;
}
}
/*
if (maxerr>1.e-2)
{
cerr << "warning -- hessian aprroximation is poor" << endl;
}
*/
for (int i = 1;i <= nvar; i++)
{
int zero_switch=0;
for (int j=1;j<=nvar;j++)
{
if (hess(i,j)!=0.0)
{
zero_switch=1;
}
}
if (!zero_switch)
{
cerr << " Hessian is 0 in row " << i << endl;
cerr << " This means that the derivative if probably identically 0 "
" for this parameter" << endl;
}
}
int ssggnn;
ln_det(hess,ssggnn);
int on1=0;
{
ofstream ofs3((char*)(ad_comm::adprogram_name + adstring(".eva")));
{
dvector se=eigenvalues(hess);
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< "unsorted:\t" << se << endl;
se=sort(se);
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< "sorted:\t" << se << endl;
if (se(se.indexmin())<=0.0)
{
negative_eigenvalue_flag=1;
cout << "Warning -- Hessian does not appear to be"
" positive definite" << endl;
}
}
ivector negflags(0,hess.indexmax());
int num_negflags=0;
{
int on = option_match(ad_comm::argc,ad_comm::argv,"-eigvec");
on1=option_match(ad_comm::argc,ad_comm::argv,"-spmin");
if (on > -1 || on1 >-1 )
{
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< eigenvalues(hess) << endl;
dmatrix ev=trans(eigenvectors(hess));
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< ev << endl;
for (int i=1;i<=ev.indexmax();i++)
{
double lam=ev(i)*hess*ev(i);
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< lam << " " << ev(i)*ev(i) << endl;
if (lam<0.0)
{
num_negflags++;
negflags(num_negflags)=i;
}
}
if ( (on1>-1) && (num_negflags>0)) // we will try to get away from
{ // saddle point
negative_eigenvalue_flag=0;
spminflag=1;
if(negdirections)
{
delete negdirections;
}
negdirections = new dmatrix(1,num_negflags);
for (int i=1;i<=num_negflags;i++)
{
(*negdirections)(i)=ev(negflags(i));
}
}
int on2 = option_match(ad_comm::argc,ad_comm::argv,"-cross");
if (on2>-1)
{ // saddle point
dmatrix cross(1,ev.indexmax(),1,ev.indexmax());
for (int i = 1;i <= ev.indexmax(); i++)
{
for (int j=1;j<=ev.indexmax();j++)
{
cross(i,j)=ev(i)*ev(j);
}
}
ofs3 << endl << " e(i)*e(j) ";
ofs3 << endl << cross << endl;
}
}
}
if (spminflag==0)
{
if (num_negflags==0)
{
hess=inv(hess);
int on=0;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-eigvec"))>-1)
{
int i;
ofs3 << "choleski decomp of correlation" << endl;
dmatrix ch=choleski_decomp(hess);
for (i=1;i<=ch.indexmax();i++)
ofs3 << ch(i)/norm(ch(i)) << endl;
ofs3 << "parameterization of choleski decomnp of correlation" << endl;
for (i=1;i<=ch.indexmax();i++)
{
dvector tmp=ch(i)/norm(ch(i));
ofs3 << tmp(1,i)/tmp(i) << endl;
}
}
}
}
}
if (spminflag==0)
{
if (on1<0)
{
for (int i = 1;i <= nvar; i++)
{
if (hess(i,i) <= 0.0)
{
hess_errorreport();
ad_exit(1);
}
}
}
{
adstring tmpstring="admodel.cov";
if (ad_comm::wd_flag)
tmpstring = ad_comm::adprogram_name + ".cov";
uostream ofs((char*)tmpstring);
ofs << nvar << hess;
ofs << gradient_structure::Hybrid_bounded_flag;
ofs << sscale;
}
}
}
// This is the model equation for the timeframe RANSAC
// B.K.P. Horn's closed form Absolute Orientation method (1987 paper)
// The convention used here is: right = (1/scale) * RMat * left + TMat
int Photogrammetry::absoluteOrientation(vector<cv::Point3d> & left, vector<cv::Point3d> & right, cv::Mat & RMat, cv::Mat & TMat, double & scale) {
//check if both vectors have the same number of size
if (left.size() != right.size()) {
cerr << "Sizes don't match" << endl;
return -1;
}
//compute the mean of the left and right set of points
cv::Point3d leftmean, rightmean;
leftmean.x = 0;
leftmean.y = 0;
leftmean.z = 0;
rightmean.x = 0;
rightmean.y = 0;
rightmean.z = 0;
for (int i = 0; i < left.size(); i++) {
leftmean.x += left[i].x;
leftmean.y += left[i].y;
leftmean.z += left[i].z;
rightmean.x += right[i].x;
rightmean.y += right[i].y;
rightmean.z += right[i].z;
}
leftmean.x /= left.size();
leftmean.y /= left.size();
leftmean.z /= left.size();
rightmean.x /= right.size();
rightmean.y /= right.size();
rightmean.z /= right.size();
cv::Mat leftmeanMat(3,1,CV_64F);
cv::Mat rightmeanMat(3,1,CV_64F);
leftmeanMat.at<double>(0,0) = leftmean.x;
leftmeanMat.at<double>(0,1) = leftmean.y;
leftmeanMat.at<double>(0,2) = leftmean.z;
rightmeanMat.at<double>(0,0) = rightmean.x;
rightmeanMat.at<double>(0,1) = rightmean.y;
rightmeanMat.at<double>(0,2) = rightmean.z;
//normalize all points
for (int i = 0; i < left.size(); i++) {
left[i].x -= leftmean.x;
left[i].y -= leftmean.y;
left[i].z -= leftmean.z;
right[i].x -= rightmean.x;
right[i].y -= rightmean.y;
right[i].z -= rightmean.z;
}
//compute scale (use the symmetrical solution)
double Sl = 0;
double Sr = 0;
// this is the symmetrical version of the scale !
for (int i = 0; i < left.size(); i++) {
Sl += left[i].x*left[i].x + left[i].y*left[i].y + left[i].z*left[i].z;
Sr += right[i].x*right[i].x + right[i].y*right[i].y + right[i].z*right[i].z;
}
scale = sqrt(Sr/Sl);
// cout << "Scale: " << scale << endl;
//create M matrix
double M[3][3];// = {0.0};
/*
// I believe this is wrong, since not summing over all left right elements, just for the last element ! KM Nov 21
for (int i = 0; i < left.size(); i++) {
M[0][0] = left[i].x*right[i].x;
M[0][1] = left[i].x*right[i].y;
M[0][2] = left[i].x*right[i].z;
M[1][0] = left[i].y*right[i].x;
M[1][1] = left[i].y*right[i].y;
M[1][2] = left[i].y*right[i].z;
M[2][0] = left[i].z*right[i].x;
M[2][1] = left[i].z*right[i].y;
M[2][2] = left[i].z*right[i].z;
}
*/
M[0][0] = 0;
M[0][1] = 0;
M[0][2] = 0;
M[1][0] = 0;
M[1][1] = 0;
M[1][2] = 0;
M[2][0] = 0;
M[2][1] = 0;
M[2][2] = 0;
for (int i = 0; i < left.size(); i++)
{
M[0][0] += left[i].x*right[i].x;
M[0][1] += left[i].x*right[i].y;
M[0][2] += left[i].x*right[i].z;
M[1][0] += left[i].y*right[i].x;
M[1][1] += left[i].y*right[i].y;
M[1][2] += left[i].y*right[i].z;
M[2][0] += left[i].z*right[i].x;
M[2][1] += left[i].z*right[i].y;
M[2][2] += left[i].z*right[i].z;
}
//create N matrix
cv::Mat N = cv::Mat::zeros(4,4,CV_64F);
N.at<double>(0,0) = M[0][0] + M[1][1] + M[2][2];
N.at<double>(0,1) = M[1][2] - M[2][1];
N.at<double>(0,2) = M[2][0] - M[0][2];
N.at<double>(0,3) = M[0][1] - M[1][0];
N.at<double>(1,0) = M[1][2] - M[2][1];
N.at<double>(1,1) = M[0][0] - M[1][1] - M[2][2];
N.at<double>(1,2) = M[0][1] + M[1][0];
N.at<double>(1,3) = M[2][0] + M[0][2];
N.at<double>(2,0) = M[2][0] - M[0][2];
N.at<double>(2,1) = M[0][1] + M[1][0];
N.at<double>(2,2) = -M[0][0] + M[1][1] - M[2][2];
N.at<double>(2,3) = M[1][2] + M[2][1];
N.at<double>(3,0) = M[0][1] - M[1][0];
N.at<double>(3,1) = M[2][0] + M[0][2];
N.at<double>(3,2) = M[1][2] + M[2][1];
N.at<double>(3,3) = -M[0][0] - M[1][1] + M[2][2];
// cout << "N: " << N << endl;
//compute eigenvalues
cv::Mat eigenvalues(1,4,CV_64FC1);
cv::Mat eigenvectors(4,4,CV_64FC1);
// cout << "eigenvalues: \n" << eigenvalues << endl;
if (!cv::eigen(N, eigenvalues, eigenvectors)) {
cerr << "eigen failed" << endl;
return -1;
}
// cout << "Eigenvalues:\n" << eigenvalues << endl;
// cout << "Eigenvectors:\n" << eigenvectors << endl;
//compute quaterion as maximum eigenvector
double q[4];
q[0] = eigenvectors.at<double>(0,0);
q[1] = eigenvectors.at<double>(0,1);
q[2] = eigenvectors.at<double>(0,2);
q[3] = eigenvectors.at<double>(0,3);
/* // I believe this changed with the openCV implementation, eigenvectors are stored in row-order !
q[0] = eigenvectors.at<double>(0,0);
q[1] = eigenvectors.at<double>(1,0);
q[2] = eigenvectors.at<double>(2,0);
q[3] = eigenvectors.at<double>(3,0);
*/
double absOfEigVec = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
q[0] /= absOfEigVec;
q[1] /= absOfEigVec;
q[2] /= absOfEigVec;
q[3] /= absOfEigVec;
cv::Mat qMat(4,1,CV_64F,q);
// cout << "q: " << qMat << endl;
//compute Rotation matrix
RMat.at<double>(0,0) = q[0]*q[0] + q[1]*q[1] - q[2]*q[2] - q[3]*q[3];
RMat.at<double>(0,1) = 2*(q[1]*q[2] - q[0]*q[3]);
RMat.at<double>(0,2) = 2*(q[1]*q[3] + q[0]*q[2]);
RMat.at<double>(1,0) = 2*(q[2]*q[1] + q[0]*q[3]);
RMat.at<double>(1,1) = q[0]*q[0] - q[1]*q[1] + q[2]*q[2] - q[3]*q[3];
RMat.at<double>(1,2) = 2*(q[2]*q[3] - q[0]*q[1]);
RMat.at<double>(2,0) = 2*(q[3]*q[1] - q[0]*q[2]);
RMat.at<double>(2,1) = 2*(q[2]*q[3] + q[0]*q[1]);
RMat.at<double>(2,2) = q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3];
// cout <<"R:\n" << RMat << endl;
// cout << "Det: " << determinant(RMat) << endl;
//find translation
cv::Mat tempMat(3,1,CV_64F);
//gemm(RMat, leftmeanMat, -1.0, rightmeanMat, 1.0, TMat); // enforcing scale of 1, since same scales in both frames
// The convention used here is: right = (1/scale) * RMat * left + TMat
TMat = -(1/scale) * RMat*leftmeanMat + rightmeanMat;
// gemm(RMat, leftmeanMat, -1.0 * scale, rightmeanMat, 1.0, TMat);
// cout << "Translation: " << TMat << endl;
return 0;
}
int main(int argc,char *argv[]) {
FILE *parameterfile=NULL,*rlxdfile=NULL, *countfile=NULL;
char * filename = NULL;
char datafilename[50];
char parameterfilename[50];
char gauge_filename[50];
char * nstore_filename = ".nstore_counter";
char * input_filename = NULL;
int rlxd_state[105];
int j,ix,mu;
int k;
struct timeval t1;
int g_nev, max_iter_ev;
double stop_prec_ev;
/* Energy corresponding to the Gauge part */
double eneg = 0., plaquette_energy = 0., rectangle_energy = 0.;
/* Acceptance rate */
int Rate=0;
/* Do we want to perform reversibility checks */
/* See also return_check_flag in read_input.h */
int return_check = 0;
/* For getopt */
int c;
/* For the Polyakov loop: */
int dir = 2;
_Complex double pl, pl4;
verbose = 0;
g_use_clover_flag = 0;
g_nr_of_psf = 1;
#ifndef XLC
signal(SIGUSR1,&catch_del_sig);
signal(SIGUSR2,&catch_del_sig);
signal(SIGTERM,&catch_del_sig);
signal(SIGXCPU,&catch_del_sig);
#endif
while ((c = getopt(argc, argv, "h?f:o:")) != -1) {
switch (c) {
case 'f':
input_filename = calloc(200, sizeof(char));
strcpy(input_filename,optarg);
break;
case 'o':
filename = calloc(200, sizeof(char));
strcpy(filename,optarg);
break;
case 'h':
case '?':
default:
usage();
break;
}
}
if(input_filename == NULL){
input_filename = "hmc.input";
}
if(filename == NULL){
filename = "output";
}
/* Read the input file */
read_input(input_filename);
mpi_init(argc, argv);
if(Nsave == 0){
Nsave = 1;
}
if(nstore == -1) {
countfile = fopen(nstore_filename, "r");
if(countfile != NULL) {
fscanf(countfile, "%d\n", &nstore);
fclose(countfile);
}
else {
nstore = 0;
}
}
if(g_rgi_C1 == 0.) {
g_dbw2rand = 0;
}
#ifndef TM_USE_MPI
g_dbw2rand = 0;
#endif
/* Reorder the mu parameter and the number of iterations */
if(g_mu3 > 0.) {
g_mu = g_mu1;
g_mu1 = g_mu3;
g_mu3 = g_mu;
j = int_n[1];
int_n[1] = int_n[3];
int_n[3] = j;
j = g_csg_N[0];
g_csg_N[0] = g_csg_N[4];
g_csg_N[4] = j;
g_csg_N[6] = j;
if(fabs(g_mu3) > 0) {
g_csg_N[6] = 0;
}
g_nr_of_psf = 3;
}
else if(g_mu2 > 0.) {
g_mu = g_mu1;
g_mu1 = g_mu2;
g_mu2 = g_mu;
int_n[3] = int_n[1];
int_n[1] = int_n[2];
int_n[2] = int_n[3];
/* For chronological inverter */
g_csg_N[4] = g_csg_N[0];
g_csg_N[0] = g_csg_N[2];
g_csg_N[2] = g_csg_N[4];
if(fabs(g_mu2) > 0) {
g_csg_N[4] = 0;
}
g_csg_N[6] = 0;
g_nr_of_psf = 2;
}
else {
g_csg_N[2] = g_csg_N[0];
if(fabs(g_mu2) > 0) {
g_csg_N[2] = 0;
}
g_csg_N[4] = 0;
g_csg_N[6] = 0;
}
for(j = 0; j < g_nr_of_psf+1; j++) {
if(int_n[j] == 0) int_n[j] = 1;
}
if(g_nr_of_psf == 3) {
g_eps_sq_force = g_eps_sq_force1;
g_eps_sq_force1 = g_eps_sq_force3;
g_eps_sq_force3 = g_eps_sq_force;
g_eps_sq_acc = g_eps_sq_acc1;
g_eps_sq_acc1 = g_eps_sq_acc3;
g_eps_sq_acc3 = g_eps_sq_acc;
}
if(g_nr_of_psf == 2) {
g_eps_sq_force = g_eps_sq_force1;
g_eps_sq_force1 = g_eps_sq_force2;
g_eps_sq_force2 = g_eps_sq_force;
g_eps_sq_acc = g_eps_sq_acc1;
g_eps_sq_acc1 = g_eps_sq_acc2;
g_eps_sq_acc2 = g_eps_sq_acc;
}
g_mu = g_mu1;
g_eps_sq_acc = g_eps_sq_acc1;
g_eps_sq_force = g_eps_sq_force1;
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND + g_dbw2rand, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND + g_dbw2rand, 0);
#endif
if ( j!= 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(0);
}
j = init_geometry_indices(VOLUMEPLUSRAND + g_dbw2rand);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for geometry_indices! Aborting...\n");
exit(0);
}
j = init_spinor_field(VOLUMEPLUSRAND/2, NO_OF_SPINORFIELDS);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(0);
}
j = init_bispinor_field(VOLUME/2, NO_OF_SPINORFIELDS);
j = init_csg_field(VOLUMEPLUSRAND/2, g_csg_N);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for csg fields! Aborting...\n");
exit(0);
}
j = init_moment_field(VOLUME, VOLUMEPLUSRAND);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for moment fields! Aborting...\n");
exit(0);
}
zero_spinor_field(g_spinor_field[DUM_DERI+4],VOLUME/2);
zero_spinor_field(g_spinor_field[DUM_DERI+5],VOLUME/2);
zero_spinor_field(g_spinor_field[DUM_DERI+6],VOLUME/2);
if(g_proc_id == 0){
/* fscanf(fp6,"%s",filename); */
/*construct the filenames for the observables and the parameters*/
strcpy(datafilename,filename); strcat(datafilename,".data");
strcpy(parameterfilename,filename); strcat(parameterfilename,".para");
parameterfile=fopen(parameterfilename, "w");
printf("# This is the hmc code for twisted Mass Wilson QCD\n\nVersion %s\n", Version);
#ifdef SSE
printf("# The code was compiled with SSE instructions\n");
#endif
#ifdef SSE2
printf("# The code was compiled with SSE2 instructions\n");
#endif
#ifdef SSE3
printf("# The code was compiled with SSE3 instructions\n");
#endif
#ifdef P4
printf("# The code was compiled for Pentium4\n");
#endif
#ifdef OPTERON
printf("# The code was compiled for AMD Opteron\n");
#endif
#ifdef _NEW_GEOMETRY
printf("# The code was compiled with -D_NEW_GEOMETRY\n");
#endif
#ifdef _GAUGE_COPY
printf("# The code was compiled with -D_GAUGE_COPY\n");
#endif
printf("# The lattice size is %d x %d x %d x %d\n",
(int)(T*g_nproc_t), (int)(LX*g_nproc_x), (int)(LY), (int)(LZ));
printf("# The local lattice size is %d x %d x %d x %d\n",
(int)(T), (int)(LX), (int)(LY),(int) LZ);
printf("# beta = %f , kappa= %f\n", g_beta, g_kappa);
printf("# mus = %f, %f, %f\n", g_mu1, g_mu2, g_mu3);
printf("# int_n_gauge = %d, int_n_ferm1 = %d, int_n_ferm2 = %d, int_n_ferm3 = %d\n",
int_n[0], int_n[1], int_n[2], int_n[3]);
printf("# g_rgi_C0 = %f, g_rgi_C1 = %f\n", g_rgi_C0, g_rgi_C1);
printf("# Number of pseudo-fermion fields: %d\n", g_nr_of_psf);
printf("# g_eps_sq_force = %e, g_eps_sq_acc = %e\n", g_eps_sq_force, g_eps_sq_acc);
printf("# Integration scheme: ");
if(integtyp == 1) printf("leap-frog (single time scale)\n");
if(integtyp == 2) printf("Sexton-Weingarten (single time scale)\n");
if(integtyp == 3) printf("leap-frog (multiple time scales)\n");
if(integtyp == 4) printf("Sexton-Weingarten (multiple time scales)\n");
if(integtyp == 5) printf("higher order and leap-frog (multiple time scales)\n");
printf("# Using %s precision for the inversions!\n",
g_relative_precision_flag ? "relative" : "absolute");
printf("# Using in chronological inverter for spinor_field 1,2,3 a history of %d, %d, %d, respectively\n",
g_csg_N[0], g_csg_N[2], g_csg_N[4]);
fprintf(parameterfile, "The lattice size is %d x %d x %d x %d\n", (int)(g_nproc_t*T), (int)(g_nproc_x*LX), (int)(LY), (int)(LZ));
fprintf(parameterfile, "The local lattice size is %d x %d x %d x %d\n", (int)(T), (int)(LX), (int)(LY), (int)(LZ));
fprintf(parameterfile, "g_beta = %f , g_kappa= %f, c_sw = %f \n",g_beta,g_kappa,g_c_sw);
fprintf(parameterfile, "boundary of fermion fields (t,x,y,z): %f %f %f %f \n",X0,X1,X2,X3);
fprintf(parameterfile, "EPS_SQ0=%e, EPS_SQ1=%e EPS_SQ2=%e, EPS_SQ3=%e \n"
,EPS_SQ0,EPS_SQ1,EPS_SQ2,EPS_SQ3);
fprintf(parameterfile, "g_eps_sq_force = %e, g_eps_sq_acc = %e\n", g_eps_sq_force, g_eps_sq_acc);
fprintf(parameterfile, "dtau=%f, Nsteps=%d, Nmeas=%d, Nsave=%d, integtyp=%d, nsmall=%d \n",
dtau,Nsteps,Nmeas,Nsave,integtyp,nsmall);
fprintf(parameterfile, "mu = %f, mu2=%f, mu3=%f\n ", g_mu, g_mu2, g_mu3);
fprintf(parameterfile, "int_n_gauge = %d, int_n_ferm1 = %d, int_n_ferm2 = %d, int_n_ferm3 = %d\n ",
int_n[0], int_n[1], int_n[2], int_n[3]);
fprintf(parameterfile, "g_rgi_C0 = %f, g_rgi_C1 = %f\n", g_rgi_C0, g_rgi_C1);
fprintf(parameterfile, "# Number of pseudo-fermion fields: %d\n", g_nr_of_psf);
fprintf(parameterfile, "# Integration scheme: ");
if(integtyp == 1) fprintf(parameterfile, "leap-frog (single time scale)\n");
if(integtyp == 2) fprintf(parameterfile, "Sexton-Weingarten (single time scale)\n");
if(integtyp == 3) fprintf(parameterfile, "leap-frog (multiple time scales)\n");
if(integtyp == 4) fprintf(parameterfile, "Sexton-Weingarten (multiple time scales)\n");
if(integtyp == 5) fprintf(parameterfile, "higher order and leap-frog (multiple time scales)\n");
fprintf(parameterfile, "Using %s precision for the inversions!\n",
g_relative_precision_flag ? "relative" : "absolute");
fprintf(parameterfile, "Using in chronological inverter for spinor_field 1,2,3 a history of %d, %d, %d, respectively\n",
g_csg_N[0], g_csg_N[2], g_csg_N[4]);
fflush(stdout); fflush(parameterfile);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary();
check_geometry();
if(g_proc_id == 0) {
#if defined GEOMETRIC
if(g_proc_id==0) fprintf(parameterfile,"The geometric series is used as solver \n\n");
#else
if(g_proc_id==0) fprintf(parameterfile,"The BICG_stab is used as solver \n\n");
#endif
fflush(parameterfile);
}
/* Continue */
if(startoption == 3){
rlxdfile = fopen(rlxd_input_filename,"r");
if(rlxdfile != NULL) {
if(g_proc_id == 0) {
fread(rlxd_state,sizeof(rlxd_state),1,rlxdfile);
}
}
else {
if(g_proc_id == 0) {
printf("%s does not exist, switching to restart...\n", rlxd_input_filename);
}
startoption = 2;
}
fclose(rlxdfile);
if(startoption != 2) {
if(g_proc_id == 0) {
rlxd_reset(rlxd_state);
printf("Reading Gauge field from file %s\n", gauge_input_filename); fflush(stdout);
}
read_gauge_field_time_p(gauge_input_filename,g_gauge_field);
}
}
if(startoption != 3){
/* Initialize random number generator */
if(g_proc_id == 0) {
rlxd_init(1, random_seed);
/* hot */
if(startoption == 1) {
random_gauge_field();
}
rlxd_get(rlxd_state);
#ifdef TM_USE_MPI
MPI_Send(&rlxd_state[0], 105, MPI_INT, 1, 99, MPI_COMM_WORLD);
MPI_Recv(&rlxd_state[0], 105, MPI_INT, g_nproc-1, 99, MPI_COMM_WORLD, &status);
rlxd_reset(rlxd_state);
#endif
}
#ifdef TM_USE_MPI
else {
MPI_Recv(&rlxd_state[0], 105, MPI_INT, g_proc_id-1, 99, MPI_COMM_WORLD, &status);
rlxd_reset(rlxd_state);
/* hot */
if(startoption == 1) {
random_gauge_field();
}
k=g_proc_id+1;
if(k==g_nproc){
k=0;
}
rlxd_get(rlxd_state);
MPI_Send(&rlxd_state[0], 105, MPI_INT, k, 99, MPI_COMM_WORLD);
}
#endif
/* Cold */
if(startoption == 0) {
unit_g_gauge_field();
}
/* Restart */
else if(startoption == 2) {
if (g_proc_id == 0){
printf("Reading Gauge field from file %s\n", gauge_input_filename); fflush(stdout);
}
read_gauge_field_time_p(gauge_input_filename,g_gauge_field);
}
}
/*For parallelization: exchange the gaugefield */
#ifdef TM_USE_MPI
xchange_gauge(g_gauge_field);
#endif
#ifdef _GAUGE_COPY
update_backward_gauge();
#endif
/*compute the energy of the gauge field*/
plaquette_energy=measure_gauge_action();
if(g_rgi_C1 > 0. || g_rgi_C1 < 0.) {
rectangle_energy = measure_rectangles();
if(g_proc_id==0){
fprintf(parameterfile,"#First rectangle value: %14.12f \n",rectangle_energy/(12.*VOLUME*g_nproc));
}
}
eneg = g_rgi_C0 * plaquette_energy + g_rgi_C1 * rectangle_energy;
/* Measure and print the Polyakov loop: */
polyakov_loop(&pl, dir);
if(g_proc_id==0){
fprintf(parameterfile,"#First plaquette value: %14.12f \n", plaquette_energy/(6.*VOLUME*g_nproc));
fprintf(parameterfile,"#First Polyakov loop value in %d-direction |L(%d)|= %14.12f \n",
dir, dir, cabs(pl));
}
dir=3;
polyakov_loop(&pl, dir);
if(g_proc_id==0){
fprintf(parameterfile,"#First Polyakov loop value in %d-direction |L(%d)|= %14.12f \n",
dir, dir, cabs(pl));
fclose(parameterfile);
}
/* set ddummy to zero */
for(ix = 0; ix < VOLUME+RAND; ix++){
for(mu=0; mu<4; mu++){
ddummy[ix][mu].d1=0.;
ddummy[ix][mu].d2=0.;
ddummy[ix][mu].d3=0.;
ddummy[ix][mu].d4=0.;
ddummy[ix][mu].d5=0.;
ddummy[ix][mu].d6=0.;
ddummy[ix][mu].d7=0.;
ddummy[ix][mu].d8=0.;
}
}
if(g_proc_id == 0) {
gettimeofday(&t1,NULL);
countfile = fopen("history_hmc_tm", "a");
fprintf(countfile, "!!! Timestamp %ld, Nsave = %d, g_mu = %e, g_mu1 = %e, g_mu_2 = %e, g_mu3 = %e, beta = %f, kappa = %f, C1 = %f, int0 = %d, int1 = %d, int2 = %d, int3 = %d, g_eps_sq_force = %e, g_eps_sq_acc = %e, ",
t1.tv_sec, Nsave, g_mu, g_mu1, g_mu2, g_mu3, g_beta, g_kappa, g_rgi_C1,
int_n[0], int_n[1], int_n[2], int_n[3], g_eps_sq_force, g_eps_sq_acc);
fprintf(countfile, "Nsteps = %d, dtau = %e, tau = %e, integtyp = %d, rel. prec. = %d\n",
Nsteps, dtau, tau, integtyp, g_relative_precision_flag);
fclose(countfile);
}
/* HERE THE CALLS FOR SOME EIGENVALUES */
/* for lowest
g_nev = 10;
*/
/* for largest
*/
g_nev = 10;
max_iter_ev = 1000;
stop_prec_ev = 1.e-10;
if(g_proc_id==0) {
printf(" Values of mu = %e mubar = %e eps = %e precision = %e \n \n", g_mu, g_mubar, g_epsbar, stop_prec_ev);
}
eigenvalues(&g_nev, operator_flag, max_iter_ev, stop_prec_ev);
g_nev = 4;
max_iter_ev = 200;
stop_prec_ev = 1.e-03;
max_eigenvalues(&g_nev, operator_flag, max_iter_ev, stop_prec_ev);
if(g_proc_id==0) {
printf(" Values of mu = %e mubar = %e eps = %e precision = %e \n \n", g_mu, g_mubar, g_epsbar, stop_prec_ev);
/*
printf(" Values of mu = %e precision = %e \n \n", g_mu, stop_prec_ev);
*/
}
/* END OF EIGENVALUES CALLS */
if(g_proc_id==0) {
rlxd_get(rlxd_state);
rlxdfile=fopen("last_state","w");
fwrite(rlxd_state,sizeof(rlxd_state),1,rlxdfile);
fclose(rlxdfile);
printf("Acceptance Rate was: %e Prozent\n", 100.*(double)Rate/(double)Nmeas);
fflush(stdout);
parameterfile = fopen(parameterfilename, "a");
fprintf(parameterfile, "Acceptance Rate was: %e Prozent\n", 100.*(double)Rate/(double)Nmeas);
fclose(parameterfile);
}
#ifdef TM_USE_MPI
MPI_Finalize();
#endif
free_gauge_tmp();
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_bispinor_field();
free_moment_field();
return(0);
}
void init_phmc() {
int max_iter_ev, j, k;
FILE *roots;
char *filename_phmc_root = "Square_root_BR_roots.dat";
char *filename_phmc_root_oox = "Square_root_BR_roots.dat.oox";
char title[100];
FILE *Const;
char *filename_const = "normierungLocal.dat";
char *filename_const_oox = "normierungLocal.dat.oox";
/* contains info about the mnl poly_monomial*/
monomial *mnl=NULL;
for(j=0;j<no_monomials;j++)
if(monomial_list[j].type == NDPOLY) mnl= monomial_list + j;
if(mnl==NULL)
fprintf(stderr,"Warning: couldnt find the NDPOLY monomial. Thats VERY strange.\n");
/* START IF PHMC */
phmc_invmaxev=1.0;
if(phmc_compute_evs != 0) {
g_mu = g_mu1;
max_iter_ev = 1000;
no_eigenvalues = 10; /* Number of lowest eigenvalues to be computed */
if(g_epsbar!=0.0)
phmc_cheb_evmin = eigenvalues_bi(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 0);
else {
phmc_cheb_evmin = eigenvalues(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 0, 0, nstore, even_odd_flag);
}
no_eigenvalues = 4; /* Number of highest eigenvalues to be computed */
if(g_epsbar!=0.0)
phmc_cheb_evmax = eigenvalues_bi(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 1);
else
phmc_cheb_evmax = eigenvalues(&no_eigenvalues, max_iter_ev, eigenvalue_precision, 1, 0, nstore, even_odd_flag);
if(g_proc_id==0)
{
printf("PHMC: Ev-max = %e \n", phmc_cheb_evmax);
printf("PHMC: Ev-min = %e \n", phmc_cheb_evmin);
}
#ifdef MPI
MPI_Finalize();
#endif
exit(0);
}
/* This is the epsilon parameter */
phmc_cheb_evmin = stilde_min/(stilde_max);
/* In the following there is the "sqrt" since the value refers to
the hermitian Dirac operator (used in EV-computation), namely
S = Q Q^dag
When "S" is applied, we call phmc_invmaxev twice !!! */
if(g_epsbar!=0.0 || phmc_exact_poly==0) phmc_invmaxev=1./(sqrt(stilde_max));
else if(g_epsbar==0.0 && phmc_exact_poly==1) phmc_invmaxev=1./stilde_max;
phmc_cheb_evmax = 1.0;
/* Here we prepare the less precise polynomial first */
degree_of_polynomial_nd(degree_of_p);
if((g_proc_id == 0) && (g_debug_level > 1)) {
printf("PHMC: interval of approximation [stilde_min, stilde_max] = [%e, %e]\n", stilde_min, stilde_max);
printf("PHMC: degree for P = %d, epsilont = %e, normalisation = %e",
phmc_dop_n_cheby-1, phmc_cheb_evmin, phmc_invmaxev);
}
/* Chi`s-spinors memory allocation */
j = init_chi_spinor_field(VOLUMEPLUSRAND/2, (phmc_dop_n_cheby+1));
if ( j!= 0) {
fprintf(stderr, "Not enough memory for PHMC Chi fields! Aborting...\n");
exit(0);
}
/* End memory allocation */
/* Here we prepare the precise polynomial */
degree_of_Ptilde();
/* THIS IS THE OVERALL CONSTANT */
/* write phmc_Cpol as the result of the simple-program files (BigC^(1/2))^1/2
since BigC^(1/2) is the constant appearing in each factor of the
multiplication defining the monomial basis representation of the
polinomial in s, while its square phmc_root (BigC^(1/2))^1/2 is the
constant appearing in the multiplication representing the
polinomial in sqrt(s) .
*/
if(mnl->MDPolyLocNormConst == -1.0){
if(!(g_epsbar!=0.0 || phmc_exact_poly==0))
filename_const=filename_const_oox;
if((Const=fopen(filename_const,"r")) != (FILE*)NULL) {
errcode = fscanf(Const, " %lf \n", &phmc_Cpol);
fclose(Const);
} else {
fprintf(stderr, "File %s is missing! Aborting...\n", filename_const);
#ifdef MPI
MPI_Finalize();
#endif
exit(6);
}
} else {
phmc_Cpol=mnl->MDPolyLocNormConst;
fprintf(stderr,"phmc_Cpol set to %e " , phmc_Cpol);
}
if(g_epsbar!=0.0 || phmc_exact_poly==0) phmc_Cpol = sqrt(phmc_Cpol);
phmc_root = calloc((2*phmc_dop_n_cheby-2),sizeof(_Complex double));
if(g_epsbar==0.0 && phmc_exact_poly == 1)
filename_phmc_root=filename_phmc_root_oox;
if(strlen(mnl->MDPolyRootsFile)!=0)
filename_phmc_root=mnl->MDPolyRootsFile;
if((roots=fopen(filename_phmc_root,"r")) != (FILE*)NULL) {
if (fgets(title, 100, roots) == NULL)
{
fprintf(stderr, "Error in reading %s! Aborting...\n", filename_phmc_root);
#ifdef MPI
MPI_Finalize();
#endif
exit(6);
}
/* Here we read in the 2n roots needed for the polinomial in sqrt(s) */
double *phmc_darray = (double*)phmc_root;
for(j = 0; j< 2 * phmc_dop_n_cheby - 2; ++j)
errcode = fscanf(roots," %d %lf %lf \n", &k, &phmc_darray[2 * j], &phmc_darray[2 * j + 1]);
fclose(roots);
}
else {
fprintf(stderr, "File %s is missing! Aborting...\n", filename_phmc_root);
#ifdef MPI
MPI_Finalize();
#endif
exit(6);
}
/* END IF PHMC */
return;
}
