int main(int argc, char** argv) { bool AddLicenceInformation = true; #if defined(COMPILE_STORM_MODULES_FOR_RMS) AddLicenceInformation = false; //* The Appl is static, otherwise it is not deleted upon call to exit(). //* TODO: checkUsage() must not call exit(), either return a status, or //* throw an exception that is caught here. //* So that the app can exit gracefully. static CravaAppl CravaAppl("RMS", "RMS - Seismic inversion module", Appl::NOTRADEMARK, ReleaseInfo::GetRmsMajorMinorVersionNumber(), ReleaseInfo::GetFullVersionNumber(), Appl::RELEASE, FileVersion(0), "SEISMIC_INVERSION", ReleaseInfo::GetLicenseVersion()); Appl::Instance()->Main(argc, argv); #endif if(0) { //test of DEM RPM double effective_bulk_modulus2; double effective_shear_modulus2; double effective_density2; DEMTools::DebugTestCalcEffectiveModulus2(effective_bulk_modulus2, effective_shear_modulus2, effective_density2); double effective_bulk_modulus; double effective_shear_modulus; double effective_density; DEMTools::DebugTestCalcEffectiveModulus4(effective_bulk_modulus, effective_shear_modulus, effective_density); //float tmp10 = 5.0f; } if (argc != 2) { printf("Usage: %s modelfile\n",argv[0]); exit(1); } LogKit::SetScreenLog(LogKit::L_Low); LogKit::StartBuffering(); Program program( 4, // Major version 0, // Minor version 0, // Patch number for bug fixes //"", // Use empty string "" for release versions " beta", // Use empty string "" for release versions -1, // Validity of licence in days (-1 = infinite) //"NORSAR", // Who this copy of CRAVA is licensed to "Norsk Regnesentral/Statoil", AddLicenceInformation); double wall=0.0, cpu=0.0; TimeKit::getTime(wall,cpu); try { XmlModelFile modelFile(argv[1]); InputFiles * inputFiles = modelFile.getInputFiles(); ModelSettings * modelSettings = modelFile.getModelSettings(); CommonData * common_data = NULL; ModelGeneral * modelGeneral = NULL; ModelAVOStatic * modelAVOstatic = NULL; ModelGravityStatic * modelGravityStatic = NULL; CravaResult * crava_result = new CravaResult(); NRLib::Random::Initialize(); if (modelFile.getParsingFailed()) { LogKit::SetFileLog(IO::FileLog()+IO::SuffixTextFiles(), modelSettings->getLogLevel()); LogKit::EndBuffering(); return(1); } std::string errTxt = inputFiles->addInputPathAndCheckFiles(); if(errTxt != "") { LogKit::WriteHeader("Error opening files"); LogKit::LogMessage(LogKit::Error, "\n"+errTxt); LogKit::LogFormatted(LogKit::Error,"\nAborting\n"); LogKit::SetFileLog(IO::FileLog()+IO::SuffixTextFiles(), modelSettings->getLogLevel()); LogKit::EndBuffering(); return(1); } /*------------------------------------------------------------ READ COMMON DATA AND PERFORM ESTIMATION BASED ON INPUT FILES AND MODEL SETTINGS -------------------------------------------------------------*/ common_data = new CommonData(modelSettings, inputFiles); int n_intervals = common_data->GetMultipleIntervalGrid()->GetNIntervals(); std::vector<SeismicParametersHolder> seismicParametersIntervals(common_data->GetMultipleIntervalGrid()->GetNIntervals()); if(modelSettings->getEstimationMode() == false) { //Loop over intervals for (int i_interval = 0; i_interval < n_intervals; i_interval++) { modelGeneral = NULL; modelAVOstatic = NULL; modelGravityStatic = NULL; std::string interval_text = ""; if (n_intervals > 1) interval_text = " for interval " + NRLib::ToString(common_data->GetMultipleIntervalGrid()->GetIntervalName(i_interval)); LogKit::WriteHeader("Setting up model" + interval_text); //Priormodell i 3D const Simbox * simbox = common_data->GetMultipleIntervalGrid()->GetIntervalSimbox(i_interval); //Expectationsgrids. NRLib::Grid to FFTGrid, fills in padding LogKit::LogFormatted(LogKit::Low,"\nBackground model..\n"); seismicParametersIntervals[i_interval].setBackgroundParametersInterval(common_data->GetBackgroundParametersInterval(i_interval), simbox->GetNXpad(), simbox->GetNYpad(), simbox->GetNZpad()); //Background grids are overwritten in avoinversion std::string interval_name = common_data->GetMultipleIntervalGrid()->GetIntervalName(i_interval); crava_result->AddBackgroundVp(seismicParametersIntervals[i_interval].GetMeanVp()); crava_result->AddBackgroundVs(seismicParametersIntervals[i_interval].GetMeanVs()); crava_result->AddBackgroundRho(seismicParametersIntervals[i_interval].GetMeanRho()); //Release background grids from common_data. common_data->ReleaseBackgroundGrids(i_interval, 0); common_data->ReleaseBackgroundGrids(i_interval, 1); common_data->ReleaseBackgroundGrids(i_interval, 2); //korrelasjonsgrid (2m) float corr_grad_I = 0.0f; float corr_grad_J = 0.0f; common_data->GetCorrGradIJ(corr_grad_I, corr_grad_J, simbox); float dt = static_cast<float>(simbox->getdz()); float low_cut = modelSettings->getLowCut(); int low_int_cut = int(floor(low_cut*(simbox->GetNZpad()*0.001*dt))); // computes the integer which corresponds to the low cut frequency. if (!modelSettings->getForwardModeling()) { LogKit::LogFormatted(LogKit::Low,"\nCorrelation parameters..\n"); seismicParametersIntervals[i_interval].setCorrelationParameters(common_data->GetPriorCovEst(), common_data->GetPriorParamCov(i_interval), common_data->GetPriorAutoCov(i_interval), common_data->GetPriorCorrT(i_interval), common_data->GetPriorCorrXY(i_interval), low_int_cut, corr_grad_I, corr_grad_J, simbox->getnx(), simbox->getny(), simbox->getnz(), simbox->GetNXpad(), simbox->GetNYpad(), simbox->GetNZpad(), simbox->getdz()); } //ModelGeneral, modelAVOstatic, modelGravityStatic, (modelTravelTimeStatic?) LogKit::LogFormatted(LogKit::Low,"\nStatic models..\n"); setupStaticModels(modelGeneral, modelAVOstatic, //modelGravityStatic, modelSettings, inputFiles, seismicParametersIntervals[i_interval], common_data, i_interval); //Loop over dataset //i. ModelAVODynamic //ii. Inversion //iii. Move model one time-step ahead //Do not run avoinversion if forward modelleing or estimationmode //Syntetic seismic is generated in CravaResult if (!modelSettings->getForwardModeling() && !modelSettings->getEstimationMode()) { int eventType; int eventIndex; modelGeneral->GetTimeLine()->ReSet(); double time; int time_index = 0; bool first = true; while(modelGeneral->GetTimeLine()->GetNextEvent(eventType, eventIndex, time) == true) { if (first == false) { modelGeneral->AdvanceTime(time_index, seismicParametersIntervals[i_interval], modelSettings); time_index++; } bool failed = false; switch(eventType) { case TimeLine::AVO : { LogKit::LogFormatted(LogKit::Low,"\nAVO inversion, time lapse "+ CommonData::ConvertIntToString(time_index) +"..\n"); failed = doTimeLapseAVOInversion(modelSettings, modelGeneral, modelAVOstatic, common_data, seismicParametersIntervals[i_interval], eventIndex, i_interval); break; } case TimeLine::TRAVEL_TIME : { LogKit::LogFormatted(LogKit::Low,"\nTravel time inversion, time lapse "+ CommonData::ConvertIntToString(time_index) +"..\n"); //failed = doTimeLapseTravelTimeInversion(modelSettings, // modelGeneral, // modelTravelTimeStatic, // inputFiles, // eventIndex, // seismicParametersIntervals[i_interval]); break; } case TimeLine::GRAVITY : { LogKit::LogFormatted(LogKit::Low,"\nGravimetric inversion, time lapse "+ CommonData::ConvertIntToString(time_index) +"..\n"); //failed = doTimeLapseGravimetricInversion(modelSettings, // modelGeneral, // modelGravityStatic, // common_data, // eventIndex, // seismicParametersIntervals[i_interval]); break; } default : failed = true; break; } if(failed) return(1); first = false; } } crava_result->AddBlockedLogs(modelGeneral->GetBlockedWells()); } //interval_loop } if (n_intervals == 1) crava_result->SetBgBlockedLogs(common_data->GetBgBlockedLogs()); if (modelSettings->getEstimationMode() == true) { LogKit::WriteHeader("Combine Results and Write to Files"); if (modelSettings->getEstimateBackground() == true && n_intervals == 1 && ((modelSettings->getOutputGridFormat() & IO::CRAVA) > 0)) { const Simbox * simbox = common_data->GetMultipleIntervalGrid()->GetIntervalSimbox(0); seismicParametersIntervals[0].setBackgroundParametersInterval(common_data->GetBackgroundParametersInterval(0), simbox->GetNXpad(), simbox->GetNYpad(), simbox->GetNZpad()); crava_result->AddBackgroundVp(seismicParametersIntervals[0].GetMeanVp()); crava_result->AddBackgroundVs(seismicParametersIntervals[0].GetMeanVs()); crava_result->AddBackgroundRho(seismicParametersIntervals[0].GetMeanRho()); } crava_result->WriteEstimationResults(modelSettings, common_data); } else { //Combine interval grids to one grid per parameter LogKit::WriteHeader("Combine Results and Write to Files"); crava_result->CombineResults(modelSettings, common_data, seismicParametersIntervals); crava_result->WriteResults(modelSettings, common_data, seismicParametersIntervals[0]); if(modelSettings->getDo4DInversion()) { bool failed; if(modelSettings->getDo4DRockPhysicsInversion()) { LogKit::WriteHeader("4D Rock Physics Inversion"); failed = modelGeneral->Do4DRockPhysicsInversion(modelSettings); if(failed) return(1); } } } if (modelSettings->getDoInversion() && FFTGrid::getMaxAllowedGrids() != FFTGrid::getMaxAllocatedGrids()) { //NBNB-PAL: Memory check is bogus at the moment. Include again when 4.0 release is fixed.") //LogKit::LogFormatted(LogKit::Warning,"\nWARNING: A memory requirement inconsistency has been detected:"); //LogKit::LogFormatted(LogKit::Warning,"\n Maximum number of grids requested : %2d",FFTGrid::getMaxAllowedGrids()); //LogKit::LogFormatted(LogKit::Warning,"\n Maximum number of grids allocated : %2d",FFTGrid::getMaxAllocatedGrids()); //TaskList::addTask("The memory usage estimate failed. Please send your XML-model file and the logFile.txt\n to the CRAVA developers."); } Timings::setTimeTotal(wall,cpu); Timings::reportAll(LogKit::Medium); TaskList::viewAllTasks(modelSettings->getTaskFileFlag()); delete modelAVOstatic; delete modelGeneral; delete common_data; delete crava_result; crava_result = NULL; delete modelSettings; modelSettings = NULL; delete inputFiles; inputFiles = NULL; Timings::reportTotal(); LogKit::LogFormatted(LogKit::Low,"\n*** CRAVA closing ***\n"); LogKit::LogFormatted(LogKit::Low,"\n*** CRAVA finished ***\n"); // // The exit(0) is needed to get the gprof output file gmon.out ... // exit(0); } catch (std::bad_alloc& ba) { std::cerr << "Out of memory: " << ba.what() << std::endl; std::string error_message = std::string("Out of memory: ") + ba.what() + "\n"; LogKit::LogMessage(LogKit::Error, error_message); } #if defined(COMPILE_STORM_MODULES_FOR_RMS) Feature& feature = FEATURE_INVERSION_EXE; LicenseSystem::Instance()->CheckIn(&feature); #endif LogKit::EndLog(); //Debug messages may occur when variables go out of scope above, so this must be the final call. return(0); }