void
ModelSettings::MakeSureDzIsSetIfNeeded(InputFiles & input_files,
std::string & err_txt)
{
if(time_dz_ < 0) {
bool need_dz = false;
std::map<std::string, int>::iterator it = time_nz_.begin();
while(need_dz == false && it != time_nz_.end()) {
if(it->second < 0)
need_dz = true;
else
++it;
}
if(need_dz == true) {
bool dz_ok = false;
const std::vector<std::vector<std::string> > seis_names = input_files.getTimeLapseSeismicFiles();
if(seis_names.size() > 0 && seis_names[0].size() > 0) {
const std::string f_name = seis_names[0][0];
if(f_name != "") {
TraceHeaderFormat thf(0); //Just pick one, not important here.
SegY master_file(f_name, 0, thf);
time_dz_ = master_file.GetDz()*1.0000001; //Guard against truncation errors.
dz_ok = true;
}
}
if(dz_ok == false)
err_txt += "No resolution given, at least one interval lacks number of layers, and no seismic file to find resolution from.\n";
}
}
}
void
FilePickerParent::SendFiles(const nsTArray<RefPtr<BlobImpl>>& aBlobs)
{
nsIContentParent* parent = TabParent::GetFrom(Manager())->Manager();
InfallibleTArray<PBlobParent*> blobs;
for (unsigned i = 0; i < aBlobs.Length(); i++) {
BlobParent* blobParent = parent->GetOrCreateActorForBlobImpl(aBlobs[i]);
if (blobParent) {
blobs.AppendElement(blobParent);
}
}
InputFiles inblobs;
inblobs.blobsParent().SwapElements(blobs);
Unused << Send__delete__(this, inblobs, mResult);
}
void
FilePickerParent::SendFiles(const nsCOMArray<nsIDOMFile>& aDomfiles)
{
ContentParent* parent = static_cast<ContentParent*>(Manager()->Manager());
InfallibleTArray<PBlobParent*> files;
for (unsigned i = 0; i < aDomfiles.Length(); i++) {
BlobParent* blob = parent->GetOrCreateActorForBlob(aDomfiles[i]);
if (blob) {
files.AppendElement(blob);
}
}
InputFiles infiles;
infiles.filesParent().SwapElements(files);
unused << Send__delete__(this, infiles, mResult);
}
void
FilePickerParent::SendFiles(const nsTArray<nsRefPtr<FileImpl>>& aFiles)
{
nsIContentParent* parent = TabParent::GetFrom(Manager())->Manager();
InfallibleTArray<PBlobParent*> files;
for (unsigned i = 0; i < aFiles.Length(); i++) {
nsRefPtr<File> file = new File(nullptr, aFiles[i]);
BlobParent* blob = parent->GetOrCreateActorForBlob(file);
if (blob) {
files.AppendElement(blob);
}
}
InputFiles infiles;
infiles.filesParent().SwapElements(files);
unused << Send__delete__(this, infiles, mResult);
}
/// This is where the link is actually performed.
bool Driver::link(const TargetInfo &targetInfo) {
// Honor -mllvm
if (!targetInfo.llvmOptions().empty()) {
unsigned numArgs = targetInfo.llvmOptions().size();
const char **args = new const char*[numArgs + 2];
args[0] = "lld (LLVM option parsing)";
for (unsigned i = 0; i != numArgs; ++i)
args[i + 1] = targetInfo.llvmOptions()[i];
args[numArgs + 1] = 0;
llvm::cl::ParseCommandLineOptions(numArgs + 1, args);
}
// Read inputs
ScopedTask readTask(getDefaultDomain(), "Read Args");
std::vector<std::vector<std::unique_ptr<File>>> files(
targetInfo.inputFiles().size());
size_t index = 0;
std::atomic<bool> fail(false);
TaskGroup tg;
for (const auto &input : targetInfo.inputFiles()) {
if (targetInfo.logInputFiles())
llvm::outs() << input.getPath() << "\n";
tg.spawn([ &, index]{
if (error_code ec = targetInfo.readFile(input.getPath(), files[index])) {
llvm::errs() << "Failed to read file: " << input.getPath() << ": "
<< ec.message() << "\n";
fail = true;
return;
}
});
++index;
}
tg.sync();
readTask.end();
if (fail)
return true;
InputFiles inputs;
for (auto &f : files)
inputs.appendFiles(f);
// Give target a chance to add files.
targetInfo.addImplicitFiles(inputs);
// assign an ordinal to each file so sort() can preserve command line order
inputs.assignFileOrdinals();
// Do core linking.
ScopedTask resolveTask(getDefaultDomain(), "Resolve");
Resolver resolver(targetInfo, inputs);
if (resolver.resolve()) {
if (!targetInfo.allowRemainingUndefines())
return true;
}
MutableFile &merged = resolver.resultFile();
resolveTask.end();
// Run passes on linked atoms.
ScopedTask passTask(getDefaultDomain(), "Passes");
PassManager pm;
targetInfo.addPasses(pm);
pm.runOnFile(merged);
passTask.end();
// Give linked atoms to Writer to generate output file.
ScopedTask writeTask(getDefaultDomain(), "Write");
if (error_code ec = targetInfo.writeFile(merged)) {
llvm::errs() << "Failed to write file '" << targetInfo.outputPath()
<< "': " << ec.message() << "\n";
return true;
}
return false;
}
/// This is where the link is actually performed.
bool Driver::link(const LinkingContext &context, raw_ostream &diagnostics) {
// Honor -mllvm
if (!context.llvmOptions().empty()) {
unsigned numArgs = context.llvmOptions().size();
const char **args = new const char *[numArgs + 2];
args[0] = "lld (LLVM option parsing)";
for (unsigned i = 0; i != numArgs; ++i)
args[i + 1] = context.llvmOptions()[i];
args[numArgs + 1] = 0;
llvm::cl::ParseCommandLineOptions(numArgs + 1, args);
}
InputGraph &inputGraph = context.inputGraph();
if (!inputGraph.numFiles())
return false;
// Read inputs
ScopedTask readTask(getDefaultDomain(), "Read Args");
std::vector<std::vector<std::unique_ptr<File> > > files(
inputGraph.numFiles());
size_t index = 0;
std::atomic<bool> fail(false);
TaskGroup tg;
std::vector<std::unique_ptr<LinkerInput> > linkerInputs;
for (auto &ie : inputGraph.inputElements()) {
if (ie->kind() == InputElement::Kind::File) {
FileNode *fileNode = (llvm::dyn_cast<FileNode>)(ie.get());
auto linkerInput = fileNode->createLinkerInput(context);
if (!linkerInput) {
llvm::outs() << fileNode->errStr(error_code(linkerInput)) << "\n";
return false;
}
linkerInputs.push_back(std::move(*linkerInput));
}
else {
llvm_unreachable("Not handling other types of InputElements");
}
}
for (const auto &input : linkerInputs) {
if (context.logInputFiles())
llvm::outs() << input->getUserPath() << "\n";
tg.spawn([ &, index]{
if (error_code ec = context.parseFile(*input, files[index])) {
diagnostics << "Failed to read file: " << input->getUserPath() << ": "
<< ec.message() << "\n";
fail = true;
return;
}
});
++index;
}
tg.sync();
readTask.end();
if (fail)
return false;
InputFiles inputs;
for (auto &f : inputGraph.internalFiles())
inputs.appendFile(*f.get());
for (auto &f : files)
inputs.appendFiles(f);
// Give target a chance to add files.
context.addImplicitFiles(inputs);
// assign an ordinal to each file so sort() can preserve command line order
inputs.assignFileOrdinals();
// Do core linking.
ScopedTask resolveTask(getDefaultDomain(), "Resolve");
Resolver resolver(context, inputs);
if (resolver.resolve()) {
if (!context.allowRemainingUndefines())
return false;
}
MutableFile &merged = resolver.resultFile();
resolveTask.end();
// Run passes on linked atoms.
ScopedTask passTask(getDefaultDomain(), "Passes");
PassManager pm;
context.addPasses(pm);
pm.runOnFile(merged);
passTask.end();
// Give linked atoms to Writer to generate output file.
ScopedTask writeTask(getDefaultDomain(), "Write");
if (error_code ec = context.writeFile(merged)) {
diagnostics << "Failed to write file '" << context.outputPath()
<< "': " << ec.message() << "\n";
return false;
}
return true;
}
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);
}
