//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; }