//Diskretisierter Zeitentwicklungsoperator
Eigen::MatrixXcd S_H(double deltaT, std::function<double(int,int,double)> H, double dXi, double xiMax, double xiMin) {
int n_max = floor((xiMax - xiMin + 3/2*dXi)/dXi);
Eigen::MatrixXd mH(n_max,n_max);
Eigen::MatrixXcd mS_H(n_max,n_max), mTemp(n_max,n_max), mTempi(n_max,n_max);
for (int i = 0; i < n_max; i++) {
for (int j = 0; j < n_max; j++) {
mH(i,j) = H((i-floor(n_max/2)),(j-floor(n_max/2)),dXi);
}
}
mTemp.real() = Eigen::MatrixXd::Identity(n_max,n_max);
mTemp.imag() = -0.5*mH*deltaT;
mTempi.real() = Eigen::MatrixXd::Identity(n_max,n_max);
mTempi.imag() = 0.5*mH*deltaT;
mS_H = mTempi.inverse() * mTemp;
return mS_H;
}
int main()
{
std::vector<int> myData = {8,71,41,31,10,11,16,46,51,31,21,13};
maxHeap<int> mH(myData);
mH.print();
mH.insert(55);
mH.print();
int n = 13;
while (n >= 0)
{
std::cout << mH.extract_max() << std::endl;
}
}
double
hyperd(N, K, n, k)
{
static mpq_t num, num2, den, q;
static mpq_t p2, t;
static mpf_t f;
static int first = 1;
double d;
double p;
if (first) {
mpq_init(num);
mpq_init(num2);
mpq_init(den);
mpq_init(q);
mpf_init(f);
mpq_init(p2);
mpq_init(t);
first = 0;
}
switch (hyperd_mode) {
case 0:
mP(&num, K, k);
mP(&p2, N - K, n - k);
mpq_mul(num2, num, p2);
mH(&p2, k + 1, n - k);
mpq_mul(num, num2, p2);
mP(&den, N, n);
mpq_div(q, num, den);
mpf_set_q(f, q);
d = mpf_get_d(f);
break;
case 1:
xx:
mC(&num2, K, k);
mC(&p2, N - K, n - k);
mpq_mul(num, num2, p2);
mC(&den, N, n);
mpq_div(q, num, den);
mpf_set_q(f, q);
d = mpf_get_d(f);
break;
case 2:
if (k == K || n - k == N - K || n == N) {
goto xx;
}
if (k == 0 || n - k == 0 || n == 0) {
goto xx;
}
p = (double)n / N;
d = dB(K, p, k) * dB(N - K, p, n - k) / dB(N, p, n);
if (d < 3e-14) {
goto xx;
}
break;
default:
fprintf(stderr, "internal error\n");
exit(1);
/* NOTREACHED */
}
return d;
}
void CONDOR( double rhoStart, double rhoEnd, int niter,
ObjectiveFunction *of, int nnode)
{
rhoStart=mmax(rhoStart,rhoEnd);
int dim=of->dim(), info, k, t, nerror;
double rho=rhoStart, delta=rhoStart, rhoNew,
lambda1, normD=rhoEnd+1.0, modelStep, reduction, r, valueOF, valueFk, bound, noise;
Vector d, tmp;
bool improvement, forceTRStep=true, evalNeeded;
initConstrainedStep(of);
// pre-create the MultInd indexes to prevent multi-thread problems:
cacheMultInd.get(dim,1); cacheMultInd.get(dim,2);
parallelInit(nnode, dim, of);
of->initData();
// points=getFirstPoints(&ValuesF, &nPtsTotal, rhoStart,of);
InterPolynomial poly(2, rho, Vector::emptyVector, of->data, of);
if (poly.NewtonBasis==NULL)
{
printf("cannot construct lagrange basis.\n");
exit(255);
}
//Base=poly.vBase;
k=poly.kbest;
valueFk=poly.valuesF[k];
fprintf(stderr,"init part 1 finished.\n");
/* InterPolynomial poly(dim,2,of);
for (;;)
{
// find index k of the best (lowest) value of the function
k=findK(ValuesF, nPtsTotal, of, points);
Base=points[k].clone();
// Base=of->xStart.clone();
valueFk=ValuesF[k];
// translation:
t=nPtsTotal; while (t--) points[t]-=Base;
// exchange index 0 and index k (to be sure best point is inside poly):
tmp=points[k];
points[k]=points[0];
points[0]=tmp;
ValuesF[k]=ValuesF[0];
ValuesF[0]=valueFk;
k=0;
poly=InterPolynomial(2, nPtsTotal, points, ValuesF);
if (poly.NewtonBasis!=NULL) break;
// the construction of the first polynomial has failed
// delete[] points;
free(ValuesF);
int kbest=findBest(of->data, of); // return 0 if startpoint is given
Vector BaseStart=of->data.getLine(kbest,dim);
double vBaseStart=((double**)of->data)[kbest][dim];
points=GenerateData(rho, BaseStart, vBaseStart, of, &ValuesF);
nPtsTotal=n;
}
*/
// update M:
fullUpdateOfM(rho,poly.vBase,of->data,poly);
fprintf(stderr,"init part 2 finished.\n");
fprintf(stderr,"init finished.\n");
// first of init all variables:
parallelImprove(&poly, &k, rho, &valueFk, poly.vBase);
// really start in parallel:
startParallelThread();
while (true)
{
// fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,QP_NF);
while (true)
{
// trust region step
while (true)
{
// poly.print();
parallelImprove(&poly, &k, rho, &valueFk, poly.vBase);
niter--;
if ((niter==0)
||(of->isConstrained&&checkForTermination(poly.NewtonPoints[k], poly.vBase, rhoEnd)))
{
poly.vBase+=poly.NewtonPoints[k];
fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,of->getNFE());
of->valueBest=valueFk;
of->xBest=poly.vBase;
// to do : compute H and Lambda
Vector vG(dim);
Matrix mH(dim,dim);
poly.gradientHessian(poly.NewtonPoints[k],vG,mH);
of->finalize(vG,mH,FullLambda.clone());
return;
}
// to debug:
fprintf(stderr,"Best Value Objective=%e (nfe=%i)\n", valueFk, of->getNFE());
d=ConstrainedL2NormMinimizer(poly,k,delta,&info,1000,&lambda1,poly.vBase,of);
// if (d.euclidianNorm()>delta)
// {
// printf("Warning d to long: (%e > %e)\n", d.euclidianNorm(), delta);
// }
normD=mmin(d.euclidianNorm(), delta);
d+=poly.NewtonPoints[k];
// next line is equivalent to reduction=valueFk-poly(d);
// BUT is more precise (no rounding error)
reduction=-poly.shiftedEval(d,valueFk);
//if (normD<0.5*rho) { evalNeeded=true; break; }
if ((normD<0.5*rho)&&(!forceTRStep)) { evalNeeded=true; break; }
// IF THE MODEL REDUCTION IS SMALL, THEN WE DO NOT SAMPLE FUNCTION
// AT THE NEW POINT. WE THEN WILL TRY TO IMPROVE THE MODEL.
noise=0.5*mmax(of->noiseAbsolute*(1+of->noiseRelative), abs(valueFk)*of->noiseRelative);
if ((reduction<noise)&&(!forceTRStep)) { evalNeeded=true; break; }
forceTRStep=false; evalNeeded=false;
if (quickHack) (*quickHack)(poly,k);
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp, &nerror);
of->saveValue(tmp,valueOF,nerror);
if (nerror)
{
// evaluation failed
delta*=0.5;
if (normD>=2*rho) continue;
break;
}
if (!of->isFeasible(tmp, &r))
{
fprintf(stderr, "violation: %e\n",r);
}
// update of delta:
r=(valueFk-valueOF)/reduction;
if (r<=0.1) delta=0.5*normD;
else if (r<0.7) delta=mmax(0.5*delta, normD);
else delta=mmax(rho+ normD, mmax(1.25*normD, delta));
// powell's heuristics:
if (delta<1.5*rho) delta=rho;
if (valueOF<valueFk)
{
t=poly.findAGoodPointToReplace(-1, rho, d,&modelStep);
k=t; valueFk=valueOF;
improvement=true;
// fprintf(stderr,"Value Objective=%e\n", valueOF);
} else
{
t=poly.findAGoodPointToReplace(k, rho, d,&modelStep);
improvement=false;
// fprintf(stderr,".");
};
if (t<0) { poly.updateM(d, valueOF); break; }
// If we are along constraints, it's more important to update
// the polynomial with points which increase its quality.
// Thus, we will skip this update to use only points coming
// from checkIfValidityIsInBound
if ((!of->isConstrained)||(improvement)||(reduction>0.0)||(normD<rho)) poly.replace(t, d, valueOF);
if (improvement) continue;
// if (modelStep>4*rho*rho) continue;
if (modelStep>2*rho) continue;
if (normD>=2*rho) continue;
break;
}
// model improvement step
forceTRStep=true;
// fprintf(stderr,"improvement step\n");
bound=0.0;
if (normD<0.5*rho)
{
bound=0.5*sqr(rho)*lambda1;
if (poly.nUpdateOfM<10) bound=0.0;
}
parallelImprove(&poly, &k, rho, &valueFk, poly.vBase);
// !! change d (if needed):
t=poly.checkIfValidityIsInBound(d, k, bound, rho );
if (t>=0)
{
if (quickHack) (*quickHack)(poly,k);
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp, &nerror);
if (nerror)
{
Vector GXk(dim);
Matrix H(dim,dim);
poly.NewtonBasis[t].gradientHessian(poly.NewtonPoints[k],GXk,H);
double rhot=rho,vmax;
while (nerror)
{
rhot*=.5;
d=LAGMAXModified(GXk,H,rhot,vmax);
d+=poly.NewtonPoints[k];
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp, &nerror);
of->saveValue(tmp,valueOF,nerror);
}
}
poly.replace(t, d, valueOF);
if ((valueOF<valueFk)&&
(of->isFeasible(tmp))) { k=t; valueFk=valueOF; };
continue;
}
// the model is perfect for this value of rho:
// OR
// we have crossed a non_linear constraint which prevent us to advance
if ((normD<=rho)||(reduction<0.0)) break;
}
// change rho because no improvement can now be made:
if (rho<=rhoEnd) break;
fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,of->getNFE());
if (rho<16*rhoEnd) rhoNew=rhoEnd;
else if (rho<250*rhoEnd) rhoNew=sqrt(rho*rhoEnd);
else rhoNew=0.1*rho;
delta=mmax(0.5*rho,rhoNew);
rho=rhoNew;
// update of the polynomial: translation of x[k].
// replace BASE by BASE+x[k]
poly.translate(poly.NewtonPoints[k]);
}
parallelFinish();
Vector vG(dim);
Matrix mH(dim,dim);
if (evalNeeded)
{
tmp=poly.vBase+d; nerror=0; valueOF=of->eval(tmp,&nerror);
of->saveValue(tmp,valueOF,nerror);
if ((nerror)||(valueOF<valueFk))
{
poly.vBase+=poly.NewtonPoints[k];
poly.gradientHessian(poly.NewtonPoints[k],vG,mH);
}
else
{
valueFk=valueOF; poly.vBase=tmp;
poly.gradientHessian(d,vG,mH);
}
} else
{
poly.vBase+=poly.NewtonPoints[k];
poly.gradientHessian(poly.NewtonPoints[k],vG,mH);
}
// delete[] points; :not necessary: done in destructor of poly which is called automatically:
fprintf(stderr,"rho=%e; fo=%e; NF=%i\n", rho,valueFk,of->getNFE());
of->valueBest=valueFk;
of->xBest=poly.vBase;
of->finalize(vG,mH,FullLambda.clone());
}
void softAbsMetric::checkEvolution(const double epsilon)
{
baseHamiltonian::checkEvolution(epsilon);
// Hessian
std::cout.precision(6);
int width = 12;
int nColumn = 5;
std::cout << "Potential Hessian (d^{2}V/dq^{i}dq^{j}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta / "
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Stepsize^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
fComputeH();
for(int i = 0; i < mDim; ++i)
{
VectorXd temp = VectorXd::Zero(mDim);
mQ(i) += epsilon;
temp += gradV();
mQ(i) -= 2.0 * epsilon;
temp -= gradV();
mQ(i) += epsilon;
temp /= 2.0 * epsilon;
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << mH(i, j)
<< std::setw(width) << std::left << temp(j)
<< std::setw(width) << std::left << (mH(i, j) - temp(j)) / (epsilon * epsilon)
<< std::endl;
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Gradient of the Hessian
std::cout.precision(6);
width = 12;
nColumn = 6;
std::cout << "Gradient of the Hessian (d^{3}V/dq^{i}dq^{j}dq^{k}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "(k)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Stepsize^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
for(int k = 0; k < mDim; ++k)
{
mAuxMatrixOne.setZero();
mQ(k) += epsilon;
fComputeH();
mAuxMatrixOne += mH;
mQ(k) -= 2.0 * epsilon;
fComputeH();
mAuxMatrixOne -= mH;
mQ(k) += epsilon;
mAuxMatrixOne /= 2.0 * epsilon;
fComputeGradH(k);
for(int i = 0; i < mDim; ++i)
{
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << k
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << mGradH.block(0, k * mDim, mDim, mDim)(i, j)
<< std::setw(width) << std::left << mAuxMatrixOne(i, j)
<< std::setw(width) << std::left << (mGradH.block(0, k * mDim, mDim, mDim)(i, j) - mAuxMatrixOne(i, j)) / (epsilon * epsilon)
<< std::endl;
}
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Metric
std::cout.precision(6);
width = 12;
nColumn = 6;
std::cout << "Gradient of the metric (dLambda^{jk}/dq^{i}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Row"
<< std::setw(width) << std::left << "Column"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "(j)"
<< std::setw(width) << std::left << "(k)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Epsilon^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
fComputeMetric();
fPrepareSpatialGradients();
for(int k = 0; k < mDim; ++k)
{
// Approximate metric gradient
MatrixXd temp = MatrixXd::Zero(mDim, mDim);
MatrixXd G = MatrixXd::Zero(mDim, mDim);
mQ(k) += epsilon;
fComputeMetric();
G.noalias() = mEigenDeco.eigenvectors() * mSoftAbsLambda.asDiagonal() * mEigenDeco.eigenvectors().transpose();
temp += G;
mQ(k) -= 2.0 * epsilon;
fComputeMetric();
G.noalias() = mEigenDeco.eigenvectors() * mSoftAbsLambda.asDiagonal() * mEigenDeco.eigenvectors().transpose();
temp -= G;
mQ(k) += epsilon;
temp /= 2.0 * epsilon;
// Exact metric gradient
fComputeMetric();
fComputeGradH(k);
mAuxMatrixOne.noalias() = mGradH.block(0, k * mDim, mDim, mDim) * mEigenDeco.eigenvectors();
mAuxMatrixTwo.noalias() = mEigenDeco.eigenvectors().transpose() * mAuxMatrixOne;
mAuxMatrixOne.noalias() = mPseudoJ.cwiseProduct(mAuxMatrixTwo);
mCacheMatrix.noalias() = mAuxMatrixOne * mEigenDeco.eigenvectors().transpose();
MatrixXd gradG = mEigenDeco.eigenvectors() * mCacheMatrix;
// Compare
for(int i = 0; i < mDim; ++i)
{
for(int j = 0; j < mDim; ++j)
{
std::cout << " "
<< std::setw(width) << std::left << k
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << j
<< std::setw(width) << std::left << gradG(i, j)
<< std::setw(width) << std::left << temp(i, j)
<< std::setw(width) << std::left << (gradG(i, j) - temp(i, j)) / (epsilon * epsilon)
<< std::endl;
}
}
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
// Hamiltonian
VectorXd gradH = dTaudq();
gradH += dPhidq();
std::cout << "pDot (-dH/dq^{i}):" << std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << " "
<< std::setw(width) << std::left << "Component"
<< std::setw(width) << std::left << "Analytic"
<< std::setw(width) << std::left << "Finite"
<< std::setw(width) << std::left << "Delta /"
<< std::endl;
std::cout << " "
<< std::setw(width) << std::left << "(i)"
<< std::setw(width) << std::left << "Derivative"
<< std::setw(width) << std::left << "Difference"
<< std::setw(width) << std::left << "Epsilon^{2}"
<< std::endl;
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
for(int i = 0; i < mDim; ++i)
{
// Finite Differences
double temp = 0.0;
mQ(i) += epsilon;
temp -= H();
mQ(i) -= 2.0 * epsilon;
temp += H();
mQ(i) += epsilon;
temp /= 2.0 * epsilon;
// Exact
double minusGradH = -gradH(i);
std::cout << " "
<< std::setw(width) << std::left << i
<< std::setw(width) << std::left << minusGradH
<< std::setw(width) << std::left << temp
<< std::setw(width) << std::left << (minusGradH - temp) / (epsilon * epsilon)
<< std::endl;
}
std::cout << " " << std::setw(nColumn * width) << std::setfill('-') << "" << std::setfill(' ') << std::endl;
std::cout << std::endl;
}
antlr::RefToken FMTLexer::nextToken()
{
antlr::RefToken theRetToken;
for (;;) {
antlr::RefToken theRetToken;
int _ttype = antlr::Token::INVALID_TYPE;
resetText();
try { // for lexical and char stream error handling
switch ( LA(1)) {
case 0x22 /* '\"' */ :
case 0x27 /* '\'' */ :
{
mSTRING(true);
theRetToken=_returnToken;
break;
}
case 0x28 /* '(' */ :
{
mLBRACE(true);
theRetToken=_returnToken;
break;
}
case 0x29 /* ')' */ :
{
mRBRACE(true);
theRetToken=_returnToken;
break;
}
case 0x2f /* '/' */ :
{
mSLASH(true);
theRetToken=_returnToken;
break;
}
case 0x2c /* ',' */ :
{
mCOMMA(true);
theRetToken=_returnToken;
break;
}
case 0x41 /* 'A' */ :
case 0x61 /* 'a' */ :
{
mA(true);
theRetToken=_returnToken;
break;
}
case 0x3a /* ':' */ :
{
mTERM(true);
theRetToken=_returnToken;
break;
}
case 0x24 /* '$' */ :
{
mNONL(true);
theRetToken=_returnToken;
break;
}
case 0x46 /* 'F' */ :
case 0x66 /* 'f' */ :
{
mF(true);
theRetToken=_returnToken;
break;
}
case 0x44 /* 'D' */ :
case 0x64 /* 'd' */ :
{
mD(true);
theRetToken=_returnToken;
break;
}
case 0x45 /* 'E' */ :
case 0x65 /* 'e' */ :
{
mE(true);
theRetToken=_returnToken;
break;
}
case 0x47 /* 'G' */ :
case 0x67 /* 'g' */ :
{
mG(true);
theRetToken=_returnToken;
break;
}
case 0x49 /* 'I' */ :
case 0x69 /* 'i' */ :
{
mI(true);
theRetToken=_returnToken;
break;
}
case 0x4f /* 'O' */ :
case 0x6f /* 'o' */ :
{
mO(true);
theRetToken=_returnToken;
break;
}
case 0x42 /* 'B' */ :
case 0x62 /* 'b' */ :
{
mB(true);
theRetToken=_returnToken;
break;
}
case 0x5a /* 'Z' */ :
{
mZ(true);
theRetToken=_returnToken;
break;
}
case 0x7a /* 'z' */ :
{
mZZ(true);
theRetToken=_returnToken;
break;
}
case 0x51 /* 'Q' */ :
case 0x71 /* 'q' */ :
{
mQ(true);
theRetToken=_returnToken;
break;
}
case 0x48 /* 'H' */ :
case 0x68 /* 'h' */ :
{
mH(true);
theRetToken=_returnToken;
break;
}
case 0x54 /* 'T' */ :
case 0x74 /* 't' */ :
{
mT(true);
theRetToken=_returnToken;
break;
}
case 0x4c /* 'L' */ :
case 0x6c /* 'l' */ :
{
mL(true);
theRetToken=_returnToken;
break;
}
case 0x52 /* 'R' */ :
case 0x72 /* 'r' */ :
{
mR(true);
theRetToken=_returnToken;
break;
}
case 0x58 /* 'X' */ :
case 0x78 /* 'x' */ :
{
mX(true);
theRetToken=_returnToken;
break;
}
case 0x2e /* '.' */ :
{
mDOT(true);
theRetToken=_returnToken;
break;
}
case 0x9 /* '\t' */ :
case 0x20 /* ' ' */ :
{
mWHITESPACE(true);
theRetToken=_returnToken;
break;
}
case 0x2b /* '+' */ :
case 0x2d /* '-' */ :
case 0x30 /* '0' */ :
case 0x31 /* '1' */ :
case 0x32 /* '2' */ :
case 0x33 /* '3' */ :
case 0x34 /* '4' */ :
case 0x35 /* '5' */ :
case 0x36 /* '6' */ :
case 0x37 /* '7' */ :
case 0x38 /* '8' */ :
case 0x39 /* '9' */ :
{
mNUMBER(true);
theRetToken=_returnToken;
break;
}
default:
if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x4f /* 'O' */ ) && (LA(4) == 0x41 /* 'A' */ )) {
mCMOA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x4f /* 'O' */ ) && (LA(4) == 0x49 /* 'I' */ )) {
mCMOI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x6f /* 'o' */ )) {
mCMoA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x44 /* 'D' */ ) && (LA(3) == 0x49 /* 'I' */ )) {
mCDI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x4d /* 'M' */ ) && (LA(3) == 0x49 /* 'I' */ )) {
mCMI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x53 /* 'S' */ ) && (LA(3) == 0x49 /* 'I' */ )) {
mCSI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x53 /* 'S' */ ) && (LA(3) == 0x46 /* 'F' */ )) {
mCSF(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x44 /* 'D' */ ) && (LA(3) == 0x57 /* 'W' */ )) {
mCDWA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x44 /* 'D' */ ) && (LA(3) == 0x77 /* 'w' */ )) {
mCDwA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x41 /* 'A' */ ) && (LA(3) == 0x50 /* 'P' */ )) {
mCAPA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x41 /* 'A' */ ) && (LA(3) == 0x70 /* 'p' */ )) {
mCApA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x25 /* '%' */ ) && (LA(2) == 0x22 /* '\"' */ || LA(2) == 0x27 /* '\'' */ )) {
mCSTRING(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x6d /* 'm' */ )) {
mCmoA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x59 /* 'Y' */ )) {
mCYI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x48 /* 'H' */ )) {
mCHI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x68 /* 'h' */ )) {
mChI(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x64 /* 'd' */ )) {
mCdwA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ ) && (LA(2) == 0x61 /* 'a' */ )) {
mCapA(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x43 /* 'C' */ || LA(1) == 0x63 /* 'c' */ ) && (true)) {
mC(true);
theRetToken=_returnToken;
}
else if ((LA(1) == 0x25 /* '%' */ ) && (true)) {
mPERCENT(true);
theRetToken=_returnToken;
}
else {
if (LA(1)==EOF_CHAR)
{
uponEOF();
_returnToken = makeToken(antlr::Token::EOF_TYPE);
}
else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
}
}
if ( !_returnToken )
goto tryAgain; // found SKIP token
_ttype = _returnToken->getType();
_ttype = testLiteralsTable(_ttype);
_returnToken->setType(_ttype);
return _returnToken;
}
catch (antlr::RecognitionException& e) {
throw antlr::TokenStreamRecognitionException(e);
}
catch (antlr::CharStreamIOException& csie) {
throw antlr::TokenStreamIOException(csie.io);
}
catch (antlr::CharStreamException& cse) {
throw antlr::TokenStreamException(cse.getMessage());
}
tryAgain:;
}
}
void DiffractionDataSingleCrystal::ImportHklIobsGroup(const string &fileName,const unsigned int skipLines)
{
//configure members
mNbRefl=0;
mNbGroup=0;
mH.resize(500);
mK.resize(500);
mL.resize(500);
mObsIntensity.resize(500);
mObsSigma.resize(500);
mGroupIndex.resize(500);
mGroupIobs.resize(500);
mGroupSigma.resize(500);
mGroupWeight.resize(500);
//Import data
{
//:TODO: Skip the lines if required !!!
cout << "inputing reflections from file : "+fileName<<endl;
ifstream fin (fileName.c_str());
if(!fin)
{
throw ObjCrystException("DiffractionDataSingleCrystal::ImportHklIobs() : \
Error opening file for input:"+fileName);
}
string buffer;
REAL h,k,l,iobs,sigma;
while(true)
{
getline(fin,buffer);
istringstream linestream(buffer);
int nn = (linestream >> h >> k >> l) ? 3 : 0;
nn += bool(linestream >> iobs);
nn += bool(linestream >> sigma);
const int n = nn;
if(n<3) break;
mH(mNbRefl)=h;
mK(mNbRefl)=k;
mL(mNbRefl)=l;
mGroupIndex(mNbRefl)=mNbGroup;
//cout<<mNbRefl<<" "<<h<<" "<<k<<" "<<l<<"(g="<<mNbGroup<<") n="<<n;
if(n>=4)
{
//cout<<" Iobs="<<iobs;
mObsIntensity(mNbRefl)=iobs;
if(n!=5)
sigma=sqrt(fabs(iobs)+1e-6);
mObsSigma(mNbRefl)=sigma;
mGroupIobs(mNbGroup)=iobs;
mGroupSigma(mNbGroup)=sigma;
mGroupWeight(mNbGroup)=1/(sigma*sigma+1e-6);
mNbGroup++;
if(mNbGroup==mGroupIobs.numElements())
{
mGroupIobs.resizeAndPreserve(mNbGroup+500);
mGroupSigma.resizeAndPreserve(mNbGroup+500);
mGroupWeight.resizeAndPreserve(mNbGroup+500);
}
}
else
{
mObsIntensity(mNbRefl)=0;
mObsSigma(mNbRefl)=0;
}
//cout<<endl;
mNbRefl++;
if(mNbRefl==mH.numElements())
{
mH.resizeAndPreserve(mNbRefl+500);
mK.resizeAndPreserve(mNbRefl+500);
mL.resizeAndPreserve(mNbRefl+500);
mObsIntensity.resizeAndPreserve(mNbRefl+500);
mObsSigma.resizeAndPreserve(mNbRefl+500);
mGroupIndex.resizeAndPreserve(mNbRefl+500);
}
if(fin.eof()) break;
}
fin.close();
}
// This must NOT be changed with this kind of data.
mGroupOption.SetChoice(2);
// So de-register the option so that it is hidden from the user's view
mOptionRegistry.DeRegister(mGroupOption);
mClockMaster.RemoveChild(mGroupOption.GetClock());
//Finish
mH.resizeAndPreserve(mNbRefl);
mK.resizeAndPreserve(mNbRefl);
mL.resizeAndPreserve(mNbRefl);
mObsIntensity.resizeAndPreserve(mNbRefl);
mObsSigma.resizeAndPreserve(mNbRefl);
mWeight.resize(mNbRefl);
mGroupIndex.resizeAndPreserve(mNbRefl);// this will change after sorting reflections
mGroupIobs.resizeAndPreserve(mNbGroup);
mGroupWeight.resizeAndPreserve(mNbGroup);
mGroupSigma.resizeAndPreserve(mNbGroup);
const REAL minIobs=mObsIntensity.max()*1e-6;
for(int i=0;i<mNbRefl;i++)
if(mObsIntensity(i)<minIobs) mWeight(i)=1./minIobs;
else mWeight(i)=1./mObsIntensity(i);
mHasObservedData=true;
mMultiplicity.resize(mNbRefl);
mMultiplicity=1;
this->PrepareHKLarrays();
{
char buf [200];
sprintf(buf,"Imported HKLIobs, with %d reflections",(int)mNbRefl);
(*fpObjCrystInformUser)((string)buf);
}
this->SortReflectionBySinThetaOverLambda();
this->CalcIcalc();
}
void DiffractionDataSingleCrystal::ImportHklIobsSigmaJanaM91(const string &fileName)
{
//configure members
mNbRefl=1000;//reasonable beginning value ?
mH.resize(mNbRefl);
mK.resize(mNbRefl);
mL.resize(mNbRefl);
mObsIntensity.resize(mNbRefl);
mObsSigma.resize(mNbRefl);
//Import data
{
cout << "inputing reflections from Jana98 file : "+fileName<<endl;
ifstream fin (fileName.c_str());
if(!fin)
{
throw ObjCrystException("DiffractionDataSingleCrystal::ImportHklIobsSigmaJanaM91() : \
Error opening file for input:"+fileName);
}
long i=0;
REAL tmpH;
REAL junk;
fin >> tmpH;
while(tmpH != 999)
{ // :TODO: A little faster....
//:TODO: Check for the end of the stream if(!fin.good()) {throw...}
i++;
if(i>=mNbRefl)
{
cout << mNbRefl << " reflections imported..." << endl;
mNbRefl+=1000;
mH.resizeAndPreserve(mNbRefl);
mK.resizeAndPreserve(mNbRefl);
mL.resizeAndPreserve(mNbRefl);
mObsIntensity.resizeAndPreserve(mNbRefl);
mObsSigma.resizeAndPreserve(mNbRefl);
}
mH(i)=tmpH;
fin >> mK(i);
fin >> mL(i);
fin >> mObsIntensity(i);
fin >> mObsSigma(i);
fin >> junk;
fin >> junk;
fin >> junk;
fin >> junk;
fin >> tmpH;
}
fin.close();
mNbRefl=i;
cout << mNbRefl << " reflections imported." << endl;
mH.resizeAndPreserve(mNbRefl);
mK.resizeAndPreserve(mNbRefl);
mL.resizeAndPreserve(mNbRefl);
mObsIntensity.resizeAndPreserve(mNbRefl);
mObsSigma.resizeAndPreserve(mNbRefl);
}
//Finish
mWeight.resize(mNbRefl);
mWeight=1;
mMultiplicity.resize(mNbRefl);
mMultiplicity=1;
// Keep a copy as squared F(hkl), to enable fourier maps
// :TODO: stop using mObsIntensity and just keep mFhklObsSq ?
mFhklObsSq=mObsIntensity;
mClockFhklObsSq.Click();
this->PrepareHKLarrays();
this->SortReflectionBySinThetaOverLambda();
cout << "Finished storing data..."<< endl ;
mHasObservedData=true;
{
char buf [200];
sprintf(buf,"Imported HKLIobsSigma from Jana, with %d reflections",(int)mNbRefl);
(*fpObjCrystInformUser)((string)buf);
}
}
void DiffractionDataSingleCrystal::ImportShelxHKLF4(const string &fileName)
{
VFN_DEBUG_ENTRY("DiffractionDataSingleCrystal::ImportShelxHKLF4():"<<fileName,10);
char buf[101];
//configure members
mNbRefl=100;
mH.resize(mNbRefl);
mK.resize(mNbRefl);
mL.resize(mNbRefl);
mObsIntensity.resize(mNbRefl);
mObsSigma.resize(mNbRefl);
long h=1,k=1,l=1,i=0;
float iobs,sigma;
//Import data
{
VFN_DEBUG_MESSAGE("inputing reflections from file (HKLF4): "<<fileName,10);
ifstream fin (fileName.c_str());
if(!fin)
{
throw ObjCrystException("DiffractionDataSingleCrystal::ImportShelxHKLF4() : Error opening file for input:"+fileName);
}
for(;;)
{
fin.getline(buf,100);
h=(int) atoi(string(buf).substr(0,4).c_str());
k=(int) atoi(string(buf).substr(4,4).c_str());
l=(int) atoi(string(buf).substr(8,4).c_str());
iobs=(float) atof(string(buf).substr(12,8).c_str());
sigma=(float) atof(string(buf).substr(20,8).c_str());
if((abs(h)+abs(k)+abs(l))==0) break;
if(i==mNbRefl)
{
mNbRefl+=100;
mH.resizeAndPreserve(mNbRefl);
mK.resizeAndPreserve(mNbRefl);
mL.resizeAndPreserve(mNbRefl);
mObsIntensity.resizeAndPreserve(mNbRefl);
mObsSigma.resizeAndPreserve(mNbRefl);
}
mH(i)=REAL(h);
mK(i)=REAL(k);
mL(i)=REAL(l);
mObsIntensity(i)=REAL(iobs);
mObsSigma(i)=REAL(sigma);
i++;
}
VFN_DEBUG_MESSAGE("Finished reading from file (HKLF4) ",10);
fin.close();
}
//Finish
mNbRefl=i;
mH.resizeAndPreserve(mNbRefl);
mK.resizeAndPreserve(mNbRefl);
mL.resizeAndPreserve(mNbRefl);
mObsIntensity.resizeAndPreserve(mNbRefl);
mObsSigma.resizeAndPreserve(mNbRefl);
mWeight.resize(mNbRefl);
this->SetWeightToInvSigma2(1e-4,0);
mHasObservedData=true;
mMultiplicity.resize(mNbRefl);
mMultiplicity=1;
// Keep a copy as squared F(hkl), to enable fourier maps
// :TODO: stop using mObsIntensity and just keep mFhklObsSq ?
mFhklObsSq=mObsIntensity;
mClockFhklObsSq.Click();
this->PrepareHKLarrays();
this->SortReflectionBySinThetaOverLambda();
{
char buf [200];
sprintf(buf,"Imported Shelx HKLF 4 file, with %d reflections",(int)mNbRefl);
(*fpObjCrystInformUser)((string)buf);
}
VFN_DEBUG_EXIT("DiffractionDataSingleCrystal::ImportShelxHKLF4() read "<<mNbRefl<<" reflections",10);
}
void DiffractionDataSingleCrystal::ImportHklIobsSigma(const string &fileName,
const long nbRefl,
const int skipLines)
{
//configure members
mNbRefl=nbRefl;
mH.resize(mNbRefl);
mK.resize(mNbRefl);
mL.resize(mNbRefl);
mObsIntensity.resize(mNbRefl);
mObsSigma.resize(mNbRefl);
//Import data
{
cout << "inputing reflections from file : "+fileName<<endl;
ifstream fin (fileName.c_str());
if(!fin)
{
throw ObjCrystException("DiffractionDataSingleCrystal::ImportHklIobsSigma() : \
Error opening file for input:"+fileName);
}
if(skipLines>0)
{//Get rid of first lines if required
char tmpComment[200];
for(int i=0;i<skipLines;i++) fin.getline(tmpComment,150);
}
cout << "Number of reflections to import : " << nbRefl << endl ;
for(long i=0;i<nbRefl;i++)
{ // :TODO: A little faster....
//:TODO: Check for the end of the stream if(!fin.good()) {throw...}
fin >> mH(i);
fin >> mK(i);
fin >> mL(i);
fin >> mObsIntensity(i);
fin >> mObsSigma(i);
//cout << mH(i)<<" "<<mK(i)<<" "<<mL(i)<<" "<<mObsIntensity(i)<<" "<<mObsSigma(i)<<endl;
}
cout << "Finished reading data>"<< endl;
fin.close();
}
//Finish
mWeight.resize(mNbRefl);
this->SetWeightToInvSigma2(1e-4,0);
mHasObservedData=true;
mMultiplicity.resize(mNbRefl);
mMultiplicity=1;
// Keep a copy as squared F(hkl), to enable fourier maps
// :TODO: stop using mObsIntensity and just keep mFhklObsSq ?
mFhklObsSq=mObsIntensity;
mClockFhklObsSq.Click();
this->PrepareHKLarrays();
this->SortReflectionBySinThetaOverLambda();
{
char buf [200];
sprintf(buf,"Imported HKLIobsSigma, with %d reflections",(int)mNbRefl);
(*fpObjCrystInformUser)((string)buf);
}
cout << "Finished storing data..."<< endl ;
}
CrystVector_long DiffractionDataSingleCrystal::SortReflectionBySinThetaOverLambda(const REAL maxSTOL)
{
TAU_PROFILE("DiffractionDataSingleCrystal::SortReflectionBySinThetaOverLambda()","void ()",TAU_DEFAULT);
VFN_DEBUG_ENTRY("DiffractionDataSingleCrystal::SortReflectionBySinThetaOverLambda()",5)
// ScatteringData::SortReflectionBySinThetaOverLambda only sorts H,K,L and multiplicity.
CrystVector_long index=this->ScatteringData::SortReflectionBySinThetaOverLambda(maxSTOL);
if(mObsIntensity.numElements()==mNbRefl)
{
CrystVector_REAL tmpObs,tmpSigma,tmpWeight;
tmpObs=mObsIntensity;
tmpSigma=mObsSigma;
tmpWeight=mWeight;
for(long i=0;i<mNbRefl;i++)
{
mObsIntensity(i)=tmpObs(index(i));
mObsSigma(i)=tmpSigma(index(i));
mWeight(i)=tmpWeight(index(i));
}
// Keep a copy as squared F(hkl), to enable fourier maps
// :TODO: stop using mObsIntensity and just keep mFhklObsSq ?
mFhklObsSq=mObsIntensity;
mClockFhklObsSq.Click();
if(mGroupOption.GetChoice()==2)
{
CrystVector_long tmp;//,oldgroup(mNbGroup);;
tmp=mGroupIndex;
for(long i=0;i<mNbRefl;i++) mGroupIndex(i)=tmp(index(i));
/*
for(long i=0;i<mNbRefl;i++)
cout<<mIntH(i)<<" "<<mIntK(i)<<" "<<mIntL(i)<<" "
<<mObsIntensity(i)<<" "<<mObsSigma(i)<<" "<<mWeight(i)<< ":"<<mGroupIndex(i)<<endl;
*/
// Now re-index the groups of reflections in
// ascending order
{
index.resize(mNbGroup);
index=-1;
long group=0;
CrystVector_REAL oldGroupIobs, oldGroupWeight,oldGroupSigma;
oldGroupIobs =mGroupIobs;
oldGroupWeight=mGroupWeight;
oldGroupSigma=mGroupSigma;
for(long i=0;i<mNbRefl;i++)
{
if(index(mGroupIndex(i))==-1)// first reflection of a group ?
{
mGroupIobs(group)=oldGroupIobs(mGroupIndex(i));
mGroupSigma(group)=oldGroupSigma(mGroupIndex(i));
mGroupWeight(group)=oldGroupWeight(mGroupIndex(i));
//oldgroup(group)=mGroupIndex(i);
index(mGroupIndex(i))=group++;
}
mGroupIndex(i)=index(mGroupIndex(i));
}
}
/*
cout<<mIntH.numElements()<<","
<<mIntK.numElements()<<","
<<mIntL.numElements()<<","
<<oldgroup.numElements()<<","<<mGroupIndex.numElements()<<endl;
for(long i=0;i<mNbRefl;i++)
cout<<mIntH(i)<<" "<<mIntK(i)<<" "<<mIntL(i)<<endl
<<" :"<<oldgroup(mGroupIndex(i))<<"->"<<mGroupIndex(i)<<endl;
*/
// Now re-group the reflections
index=SortSubs(mGroupIndex);
{
CrystVector_long oldH,oldK,oldL,oldMult;
oldH=mH;
oldK=mK;
oldL=mL;
oldMult=mMultiplicity;
tmpObs=mObsIntensity;
tmpSigma=mObsSigma;
tmpWeight=mWeight;
for(long i=0;i<mNbRefl;i++)
{
const long subs=index(i);
mH(i)=oldH(subs);
mK(i)=oldK(subs);
mL(i)=oldL(subs);
mMultiplicity(i)=oldMult(subs);
mObsIntensity(i)=tmpObs(subs);
mObsSigma(i)=tmpSigma(subs);
mWeight(i)=tmpWeight(subs);
}
mClockHKL.Click();
this->PrepareHKLarrays();
this->CalcSinThetaLambda();
}
// re-write mGroupIndex so that it marks the
// last reflection of each group.
index=mGroupIndex;
mGroupIndex.resize(mNbGroup);
long group=0;
for(long i=0;i<mNbRefl;i++)
if(index(i)!=group)
mGroupIndex(group++)=i;
mGroupIndex(mNbGroup-1)=mNbRefl;
}
}
else
{// if there are no observed values, enter dummy ones
mObsIntensity.resize(mNbRefl);
mObsSigma.resize(mNbRefl);
mWeight.resize(mNbRefl);
mObsIntensity=100.;
mObsSigma=1.;
mWeight=1.;
mFhklObsSq.resize(0);
mClockFhklObsSq.Click();
}
VFN_DEBUG_EXIT("DiffractionDataSingleCrystal::SortReflectionBySinThetaOverLambda()",5)
return index;
}
