Exemplo n.º 1
0
void computeGravityAndTraveledDistance(const QUESO::FullEnvironment& env) {
  struct timeval timevalNow;
  
  gettimeofday(&timevalNow, NULL);
  if (env.fullRank() == 0) {
    std::cout << "\nBeginning run of 'Gravity + Projectile motion' example at "
              << ctime(&timevalNow.tv_sec)
              << "\n my fullRank = "         << env.fullRank()
              << "\n my subEnvironmentId = " << env.subId()
              << "\n my subRank = "          << env.subRank()
              << "\n my interRank = "        << env.inter0Rank()
               << std::endl << std::endl;
  }

  // Just examples of possible calls
  if ((env.subDisplayFile()       ) && 
      (env.displayVerbosity() >= 2)) {
    *env.subDisplayFile() << "Beginning run of 'Gravity + Projectile motion' example at "
                          << ctime(&timevalNow.tv_sec)
                          << std::endl;
  }
  env.fullComm().Barrier();
  env.subComm().Barrier();  // Just an example of a possible call
  
  //================================================================
  // Statistical inverse problem (SIP): find posterior PDF for 'g'
  //================================================================
  gettimeofday(&timevalNow, NULL);
  if (env.fullRank() == 0) {
    std::cout << "Beginning 'SIP -> Gravity estimation' at "
              << ctime(&timevalNow.tv_sec)
              << std::endl;
  }

  //------------------------------------------------------
  // SIP Step 1 of 6: Instantiate the parameter space
  //------------------------------------------------------
  QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> paramSpace(env, "param_", 1, NULL);

  //------------------------------------------------------
  // SIP Step 2 of 6: Instantiate the parameter domain
  //------------------------------------------------------
  QUESO::GslVector paramMinValues(paramSpace.zeroVector());
  QUESO::GslVector paramMaxValues(paramSpace.zeroVector());
  
  paramMinValues[0] = 8.;
  paramMaxValues[0] = 11.;
  
  QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix>
    paramDomain("param_",
      paramSpace,
      paramMinValues,
      paramMaxValues);
  
  //------------------------------------------------------
  // SIP Step 3 of 6: Instantiate the likelihood function 
  // object to be used by QUESO.
  //------------------------------------------------------
  likelihoodRoutine_Data likelihoodRoutine_Data(env);
  QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix>
    likelihoodFunctionObj("like_",
			  paramDomain,
			  likelihoodRoutine,
			  (void *) &likelihoodRoutine_Data,
			  true); // the routine computes [ln(function)]
    
  //------------------------------------------------------
  // SIP Step 4 of 6: Define the prior RV
  //------------------------------------------------------
  
#ifdef PRIOR_IS_GAUSSIAN
  QUESO::GslVector meanVector( paramSpace.zeroVector() );
  meanVector[0] = 9;
 
  QUESO::GslMatrix covMatrix = QUESO::GslMatrix(paramSpace.zeroVector());
  covMatrix(0,0) = 1.; 
  
  // Create a Gaussian prior RV
  QUESO::GaussianVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_",paramDomain,meanVector,covMatrix);
  
#else
  // Create an uniform prior RV
  QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix> priorRv("prior_",paramDomain);
  
#endif
  
  //------------------------------------------------------
  // SIP Step 5 of 6: Instantiate the inverse problem
  //------------------------------------------------------
  QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix>
    postRv("post_",  // Extra prefix before the default "rv_" prefix
           paramSpace);
        
  QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix>
    ip("",          // No extra prefix before the default "ip_" prefix
       NULL, 
       priorRv, 
       likelihoodFunctionObj, 
       postRv); 

  //------------------------------------------------------
  // SIP Step 6 of 6: Solve the inverse problem, that is,
  // set the 'pdf' and the 'realizer' of the posterior RV
  //------------------------------------------------------
  std::cout << "Solving the SIP with Metropolis Hastings" 
	    << std::endl << std::endl;  

  QUESO::GslVector paramInitials(paramSpace.zeroVector());
  priorRv.realizer().realization(paramInitials);

  QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
  proposalCovMatrix(0,0) = std::pow( fabs(paramInitials[0])/20. , 2. );

  ip.solveWithBayesMetropolisHastings(NULL, paramInitials, &proposalCovMatrix);

  //================================================================
  // Statistical forward problem (SFP): find the max distance 
  // traveled by an object in projectile motion; input pdf for 'g' 
  // is the solution of the SIP above.
  //================================================================
  gettimeofday(&timevalNow, NULL);
  std::cout << "Beginning 'SFP -> Projectile motion' at " 
            << ctime(&timevalNow.tv_sec)
            << std::endl;
	    
  //------------------------------------------------------
  // SFP Step 1 of 6: Instantiate the parameter *and* qoi spaces. 
  // SFP input RV = FIP posterior RV, so SFP parameter space
  // has been already defined.
  //------------------------------------------------------
  QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix> qoiSpace(env, "qoi_", 1, NULL);
  
  //------------------------------------------------------
  // SFP Step 2 of 6: Instantiate the parameter domain 
  //------------------------------------------------------
  
  // Not necessary because input RV of the SFP = output RV of SIP. 
  // Thus, the parameter domain has been already defined.
  
  //------------------------------------------------------ 
  // SFP Step 3 of 6: Instantiate the qoi function object 
  // to be used by QUESO.
  //------------------------------------------------------
  qoiRoutine_Data qoiRoutine_Data;
  qoiRoutine_Data.m_angle          = M_PI/4.0; //45 degrees (radians)
  qoiRoutine_Data.m_initialVelocity= 5.;      //initial speed (m/s) 
  qoiRoutine_Data.m_initialHeight  = 0.;       //initial height (m)
  
  QUESO::GenericVectorFunction<QUESO::GslVector,QUESO::GslMatrix,QUESO::GslVector,QUESO::GslMatrix>
    qoiFunctionObj("qoi_",
                   paramDomain,
                   qoiSpace,
                   qoiRoutine,
                   (void *) &qoiRoutine_Data);
      
  //------------------------------------------------------
  // SFP Step 4 of 6: Define the input RV
  //------------------------------------------------------
  
  // Not necessary because input RV of SFP = output RV of SIP 
  // (postRv).
      
  //------------------------------------------------------
  // SFP Step 5 of 6: Instantiate the forward problem
  //------------------------------------------------------
  QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix> qoiRv("qoi_", qoiSpace);
  
  QUESO::StatisticalForwardProblem<QUESO::GslVector,QUESO::GslMatrix,QUESO::GslVector,QUESO::GslMatrix>
    fp("",
       NULL,
       postRv,
       qoiFunctionObj,
       qoiRv);

  //------------------------------------------------------
  // SFP Step 6 of 6: Solve the forward problem
  //------------------------------------------------------
  std::cout << "Solving the SFP with Monte Carlo" 
            << std::endl << std::endl;  
  fp.solveWithMonteCarlo(NULL);

  //------------------------------------------------------
  gettimeofday(&timevalNow, NULL);
  if ((env.subDisplayFile()       ) && 
      (env.displayVerbosity() >= 2)) {
    *env.subDisplayFile() << "Ending run of 'Gravity + Projectile motion' example at "
                          << ctime(&timevalNow.tv_sec)
                          << std::endl;
  }
  if (env.fullRank() == 0) {
    std::cout << "Ending run of 'Gravity + Projectile motion' example at "
              << ctime(&timevalNow.tv_sec)
              << std::endl;
  }

  return;
}
Exemplo n.º 2
0
void compute(const QUESO::FullEnvironment& env, unsigned int numModes) {
  ////////////////////////////////////////////////////////
  // Step 1 of 5: Instantiate the parameter space
  ////////////////////////////////////////////////////////


#ifdef APPLS_MODAL_USES_CONCATENATION
  QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix>
    paramSpaceA(env, "paramA_", 2, NULL);
  QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix>
    paramSpaceB(env, "paramB_", 1, NULL);
#endif
  QUESO::VectorSpace<QUESO::GslVector, QUESO::GslMatrix>
    paramSpace(env, "param_", 3, NULL);

  ////////////////////////////////////////////////////////
  // Step 2 of 5: Instantiate the parameter domain
  ////////////////////////////////////////////////////////
#ifdef APPLS_MODAL_USES_CONCATENATION
  QUESO::GslVector paramMinsA(paramSpaceA.zeroVector());
  paramMinsA[0] = 0.;
  paramMinsA[1] = 0.;
  QUESO::GslVector paramMaxsA(paramSpaceA.zeroVector());
  paramMaxsA[0] = 3.;
  paramMaxsA[1] = 3.;
  QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix>
  
  paramDomainA("paramA_",paramSpaceA,paramMinsA,paramMaxsA);

  QUESO::GslVector paramMinsB(paramSpaceB.zeroVector());
  paramMinsB[0] = 0.;
  QUESO::GslVector paramMaxsB(paramSpaceB.zeroVector());
  paramMaxsB[0] = INFINITY;
  QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix>
    paramDomainB("paramB_",paramSpaceB,paramMinsB,paramMaxsB);

  QUESO::ConcatenationSubset<QUESO::GslVector,QUESO::GslMatrix>
    paramDomain("",paramSpace,paramDomainA,paramDomainB);
#else
  QUESO::GslVector paramMins(paramSpace.zeroVector());
  paramMins[0] = 0.;
  paramMins[1] = 0.;
  paramMins[2] = 0.;
  QUESO::GslVector paramMaxs(paramSpace.zeroVector());
  paramMaxs[0] = 3.;
  paramMaxs[1] = 3.;
  paramMaxs[2] = .3;
  QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix>
    paramDomain("param_",paramSpace,paramMins,paramMaxs);
#endif

  ////////////////////////////////////////////////////////
  // Step 3 of 5: Instantiate the likelihood function object
  ////////////////////////////////////////////////////////
  likelihoodRoutine_DataType likelihoodRoutine_Data;
 
  likelihoodRoutine_Data.numModes = numModes;
  QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix>
    likelihoodFunctionObj("like_",
                          paramDomain,
                          likelihoodRoutine,
                          (void *) &likelihoodRoutine_Data,
                          true); // routine computes [-2.*ln(function)]
  
    ////////////////////////////////////////////////////////
  // Step 4 of 5: Instantiate the inverse problem
  ////////////////////////////////////////////////////////
#ifdef APPLS_MODAL_USES_CONCATENATION
  QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix>
    priorRvA("priorA_", paramDomainA);
 
  QUESO::GslVector alpha(paramSpaceB.zeroVector());
  alpha[0] = 3.;
  QUESO::GslVector beta(paramSpaceB.zeroVector());
  if (numModes == 1) {
    beta[0] = 0.09709133373799;
  }
  else {
    beta[0] = 0.08335837191688;
  }
  QUESO::InverseGammaVectorRV<QUESO::GslVector,QUESO::GslMatrix>
    priorRvB("priorB_", paramDomainB,alpha,beta);

  QUESO::ConcatenatedVectorRV<QUESO::GslVector,QUESO::GslMatrix>
    priorRv("prior_", priorRvA, priorRvB, paramDomain);
#else
  QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix>
    priorRv("prior_", paramDomain);
#endif

  QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix>
    postRv("post_", paramSpace);

  QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix>
    ip("", NULL, priorRv, likelihoodFunctionObj, postRv);

  ////////////////////////////////////////////////////////
  // Step 5 of 5: Solve the inverse problem
  ////////////////////////////////////////////////////////
  ip.solveWithBayesMLSampling();

  ////////////////////////////////////////////////////////
  // Print some statistics
  ////////////////////////////////////////////////////////
  unsigned int numPosTotal = postRv.realizer().subPeriod();
  if (env.subDisplayFile()) {
    *env.subDisplayFile() << "numPosTotal = " << numPosTotal
                          << std::endl;
  }

  QUESO::GslVector auxVec(paramSpace.zeroVector());
  unsigned int numPosTheta1SmallerThan1dot5 = 0;
  for (unsigned int i = 0; i < numPosTotal; ++i) {
    postRv.realizer().realization(auxVec);
    if (auxVec[0] < 1.5) numPosTheta1SmallerThan1dot5++;
  }

  if (env.subDisplayFile()) {
    *env.subDisplayFile() << "numPosTheta1SmallerThan1dot5 = " << numPosTheta1SmallerThan1dot5
                          << ", ratio = " << ((double) numPosTheta1SmallerThan1dot5)/((double) numPosTotal)
                          << std::endl;
  }

  return;
}
Exemplo n.º 3
0
int main(int argc, char **argv) {
  MPI_Init(&argc, &argv);

  QUESO::EnvOptionsValues options;
  options.m_numSubEnvironments = 1;
  options.m_subDisplayFileName = "debug_output";
  options.m_seed = 1.0;
  options.m_checkingLevel = 1;
  options.m_platformName = "my_platform";
  options.m_displayVerbosity = 20;

  /* std::set<unsigned int> subDisplayAllowed; */
  /* subDisplayAllowed.insert(0); */

  /* options.m_subDisplayAllowedSet = subDisplayAllowed; */
  /* options.m_subDisplayAllowAll = 0; */

  QUESO::FullEnvironment *env = new QUESO::FullEnvironment(MPI_COMM_WORLD, "", "", &options);

  if (!env->fullEnvIsReady()) {
    std::cerr << "Full env ready test failed" << std::endl;
    return 1;
  }

  if (env->displayVerbosity() > 10) {
    std::cout << "have high enough display verbosity" << std::endl;
  }
  else {
    std::cout << "not high enough" << std::endl;
  }

  if (env->worldRank() != 0) {
    std::cerr << "World rank test failed" << std::endl;
    return 1;
  }

  if (env->subDisplayFileName() != "debug_output") {
    std::cerr << "subDisplayFileName test failed" << std::endl;
    return 1;
  }

  env->setOptionsInputFileAccessState(false);
  if (env->optionsInputFileName() != "") {
    std::cerr << "Input file acces state test failed" << std::endl;
    return 1;
  }
  env->setOptionsInputFileAccessState(true);

  if (env->checkingLevel() != options.m_checkingLevel) {
    std::cerr << "Checking level test failed" << std::endl;
    return 1;
  }

  if (env->seed() != options.m_seed) {
    std::cerr << "Seed test failed" << std::endl;
    return 1;
  }

#ifdef QUESO_USES_NEW_RNG_CLASS
  env->resetSeed(2);
  if (env->seed() != 2) {
    std::cerr << "Second seed test failed" << std::endl;
    return 1;
  }

  env->resetSeed(-2);
  if (env->seed() != (2 + env->worldRank())) {
    std::cerr << "Third seed test failed" << std::endl;
    return 1;
  }
#else
  env->resetGslSeed(2);
  if (gsl_rng_default_seed != 2) {
    std::cerr << "Second seed test failed" << std::endl;
    return 1;
  }

  env->resetGslSeed(-2);
  if (gsl_rng_default_seed != (2 + env->worldRank())) {
    std::cerr << "Third seed test failed" << std::endl;
    return 1;
  }
#endif
  if (env->platformName() != options.m_platformName) {
    std::cerr << "Platform name test failed" << std::endl;
    return 1;
  }

  env->resetIdentifyingString("my_identifying_string");
  if (env->identifyingString() != "my_identifying_string") {
    std::cerr << "Identifying string test failed" << std::endl;
    return 1;
  }

  delete env;
  MPI_Finalize();

  /*
   * This code should never get here. If it does, the bash script that wraps
   * around it negates the return value, making this a failure
   */
  return 0;
}
Exemplo n.º 4
0
//------------------------------------------------------
//------------------------------------------------------
//------------------------------------------------------
void debug_hyst(const QUESO::FullEnvironment& env) {
  unsigned int numFloors = 4;
  unsigned int numTimeSteps = 401;

  std::vector<double> accel(numTimeSteps,0.);
  FILE *inp;
  inp = fopen("an.txt","r");
  unsigned int numObservations = 0;
  double tmpA;
  while (fscanf(inp,"%lf",&tmpA) != EOF) {
    UQ_FATAL_TEST_MACRO((numObservations >= accel.size()),
                        env.fullRank(),
                        "debug_hyst()",
                        "input file has too many lines");
    accel[numObservations] = tmpA;
    numObservations++;
  }
  UQ_FATAL_TEST_MACRO((numObservations != accel.size()),
                      env.fullRank(),
                      "debug_hyst()",
                      "input file has a smaller number of observations than expected");

  QUESO::VectorSpace<> floorSpace(env, "floor_", numFloors, NULL);

  QUESO::GslVector kVec(floorSpace.zeroVector());
  kVec[0] = 2.20e+7;
  kVec[1] = 2.00e+7;
  kVec[2] = 1.70e+7;
  kVec[3] = 1.45e+7;

  QUESO::GslVector rVec(floorSpace.zeroVector());
  rVec[0] = 0.1;
  rVec[1] = 0.1;
  rVec[2] = 0.1;
  rVec[3] = 0.1;

  QUESO::GslVector uVec(floorSpace.zeroVector());
  uVec[0] = 0.008;
  uVec[1] = 0.008;
  uVec[2] = 0.007;
  uVec[3] = 0.007;

  double rho   = 7.959e-1 ;//0.1976;
  double gamma = 2.500e-3 ; //0.0038;

  std::vector<double> t(numTimeSteps,0.);
  QUESO::SequenceOfVectors<> u     (floorSpace,numTimeSteps,""); // absolute displacement
  QUESO::SequenceOfVectors<> ud    (floorSpace,numTimeSteps,""); // velocity
  QUESO::SequenceOfVectors<> udd   (floorSpace,numTimeSteps,""); // acceleration
  QUESO::SequenceOfVectors<> resfor(floorSpace,numTimeSteps,""); // restoring force
  QUESO::SequenceOfVectors<> ru    (floorSpace,numTimeSteps,""); // relative displacement

  u.setPositionValues     (0,floorSpace.zeroVector());
  ud.setPositionValues    (0,floorSpace.zeroVector());
  udd.setPositionValues   (0,floorSpace.zeroVector());
  resfor.setPositionValues(0,floorSpace.zeroVector());
  ru.setPositionValues    (0,floorSpace.zeroVector());

  QUESO::GslVector massVec(floorSpace.zeroVector());
  massVec.cwSet(2.0e+4);

  hystereticModel(env,
                  massVec,
                  kVec,
                  rVec,
                  uVec,
                  rho,
                  gamma,
                  accel,
                  t, // output
                  u,
                  ud,
                  udd,
                  resfor,
                  ru);

  std::set<unsigned int> auxSet;
  auxSet.insert(0);

  // Writing some data to the file 'outputData/cpp_output.m'
  std::ofstream myFile;
  myFile.open ("outputData/cpp_output.m");

  // Write 't_cpp'
  myFile << "t_cpp = zeros(" << 1 << "," << numTimeSteps << ");\n"
          << "t_cpp = [";
  for (unsigned int j = 0; j < numTimeSteps; ++j) {
    myFile << t[j] << " ";
  }
  myFile << "];" << std::endl;

  // Write 'a_cpp'
  myFile << "a_cpp = zeros(" << 1 << "," << numTimeSteps << ");\n"
          << "a_cpp = [";
  for (unsigned int j = 0; j < numTimeSteps; ++j) {
    myFile << accel[j] << " ";
  }
  myFile << "];" << std::endl;

  QUESO::GslVector auxVec(floorSpace.zeroVector());

  // Write 'u_cpp'
  myFile << "u_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
          << "u_cpp = [";
  for (unsigned int i = 0; i < numFloors; ++i) {
    for (unsigned int j = 0; j < numTimeSteps; ++j) {
      u.getPositionValues(j,auxVec);
      myFile << auxVec[i] << " ";
    }
    myFile << std::endl;
  }
  myFile << "];" << std::endl;

  // Write 'ud_cpp'
  myFile << "ud_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
          << "ud_cpp = [";
  for (unsigned int i = 0; i < numFloors; ++i) {
    for (unsigned int j = 0; j < numTimeSteps; ++j) {
      ud.getPositionValues(j,auxVec);
      myFile << auxVec[i] << " ";
    }
    myFile << std::endl;
  }
  myFile << "];" << std::endl;

  // Write 'udd_cpp'
  myFile << "udd_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
          << "udd_cpp = [";
  for (unsigned int i = 0; i < numFloors; ++i) {
    for (unsigned int j = 0; j < numTimeSteps; ++j) {
      udd.getPositionValues(j,auxVec);
      myFile << auxVec[i] << " ";
    }
    myFile << std::endl;
  }
  myFile << "];" << std::endl;

  // Write 'resfor_cpp'
  myFile << "resfor_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
          << "resfor_cpp = [";
  for (unsigned int i = 0; i < numFloors; ++i) {
    for (unsigned int j = 0; j < numTimeSteps; ++j) {
      resfor.getPositionValues(j,auxVec);
      myFile << auxVec[i] << " ";
    }
    myFile << std::endl;
  }
  myFile << "];" << std::endl;

  // Write 'ru_cpp'
  myFile << "ru_cpp = zeros(" << numFloors << "," << numTimeSteps << ");\n"
          << "ru_cpp = [";
  for (unsigned int i = 0; i < numFloors; ++i) {
    for (unsigned int j = 0; j < numTimeSteps; ++j) {
      ru.getPositionValues(j,auxVec);
      myFile << auxVec[i] << " ";
    }
    myFile << std::endl;
  }
  myFile << "];" << std::endl;

  myFile.close();

  return;
}