OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

using SegmentSetConstPtr and SegmentConstPtr

Browse Source
This commit is contained in:
Kai Bao
2015-11-04 16:33:15 +01:00
parent bc2f7f1808
commit 65e75f2243
6 changed files with 73 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
opm/parser/eclipse/EclipseState/Schedule/Segment.cpp
View File

@@ -34,6 +34,20 @@ namespace Opm {
{
}
Segment::Segment(std::shared_ptr<const Segment> segment_in)
: m_segment_number(segment_in->segmentNumber()),
m_branch(segment_in->branchNumber()),
m_outlet_segment(segment_in->outletSegment()),
m_length(segment_in->length()),
m_depth(segment_in->depth()),
m_internal_diameter(segment_in->internalDiameter()),
m_roughness(segment_in->roughness()),
m_cross_area(segment_in->crossArea()),
m_volume(segment_in->volume()),
m_data_ready(segment_in->dataReady())
{
}
int Segment::segmentNumber() const {
return m_segment_number;

1
opm/parser/eclipse/EclipseState/Schedule/Segment.hpp
View File

@@ -34,6 +34,7 @@ namespace Opm {
Segment(int segment_number_in, int branch_in, int outlet_segment_in, double length_in, double depth_in,
double internal_diameter_in, double roughness_in, double cross_area_in, double volume_in, bool data_ready_in);
Segment(std::shared_ptr<const Segment> segment_in);
int segmentNumber() const;
int branchNumber() const;

34
opm/parser/eclipse/EclipseState/Schedule/SegmentSet.cpp
View File

@@ -48,11 +48,7 @@ namespace Opm {
return m_multiphase_model;
}
SegmentPtr& SegmentSet::operator[](size_t idx) {
return m_segments[idx];
}
SegmentPtr SegmentSet::operator[](size_t idx) const {
SegmentConstPtr SegmentSet::operator[](size_t idx) const {
return m_segments[idx];
}
@@ -65,6 +61,20 @@ namespace Opm {
}
}
void SegmentSet::addSegment(SegmentPtr new_segment) {
// decide whether to push_back or insert
int segment_number = new_segment->segmentNumber();
const int segment_location = numberToLocation(segment_number);
if (segment_location < 0) { // it is a new segment
m_number_to_location[segment_number] = numberSegment();
m_segments.push_back(new_segment);
} else { // the segment already exists
m_segments[segment_location] = new_segment;
}
}
SegmentSet* SegmentSet::shallowCopy() const {
SegmentSet* copy = new SegmentSet();
copy->m_well_name = m_well_name;
@@ -104,12 +114,12 @@ namespace Opm {
// the main branch is 1 instead of 0
// the segment number for top segment is also 1
if (m_length_depth_type == WellSegment::INC) {
SegmentPtr top_segment(new Segment(1, 1, 0, 0., 0., meaningless_value, meaningless_value, meaningless_value,
m_volume_top, false));
SegmentConstPtr top_segment(new Segment(1, 1, 0, 0., 0., meaningless_value, meaningless_value, meaningless_value,
m_volume_top, false));
m_segments.push_back(top_segment);
} else if (m_length_depth_type == WellSegment::ABS) {
SegmentPtr top_segment(new Segment(1, 1, 0, m_length_top, m_depth_top, meaningless_value, meaningless_value,
meaningless_value, m_volume_top, true));
SegmentConstPtr top_segment(new Segment(1, 1, 0, m_length_top, m_depth_top, meaningless_value, meaningless_value,
meaningless_value, m_volume_top, true));
m_segments.push_back(top_segment);
}
@@ -169,13 +179,13 @@ namespace Opm {
}
if (m_length_depth_type == WellSegment::INC) {
m_segments.push_back(std::make_shared<Segment>(i, branch, outlet_segment, segment_length, depth_change,
m_segments.push_back(std::make_shared<const Segment>(i, branch, outlet_segment, segment_length, depth_change,
diameter, roughness, area, volume, false));
} else if (i == segment2) {
m_segments.push_back(std::make_shared<Segment>(i, branch, outlet_segment, segment_length, depth_change,
m_segments.push_back(std::make_shared<const Segment>(i, branch, outlet_segment, segment_length, depth_change,
diameter, roughness, area, volume, true));
} else {
m_segments.push_back(std::make_shared<Segment>(i, branch, outlet_segment, meaningless_value, meaningless_value,
m_segments.push_back(std::make_shared<const Segment>(i, branch, outlet_segment, meaningless_value, meaningless_value,
diameter, roughness, area, volume, false));
}
}

7
opm/parser/eclipse/EclipseState/Schedule/SegmentSet.hpp
View File

@@ -44,14 +44,13 @@ namespace Opm {
WellSegment::MultiPhaseModelEnum multiPhaseModel() const;
int numberToLocation(const int segment_number) const;
void addSegment(SegmentPtr new_segment);
void segmentsFromWELSEGSKeyword(DeckKeywordConstPtr welsegsKeyword);
SegmentSet* shallowCopy() const;
SegmentPtr& operator[](size_t idx);
SegmentPtr operator[](size_t idx) const;
SegmentConstPtr operator[](size_t idx) const;
private:
@@ -80,7 +79,7 @@ namespace Opm {
// while they are not supported by the keyword at the moment.
// std::vector<SegmentConstPtr> m_segments;
std::vector<SegmentPtr> m_segments;
std::vector<SegmentConstPtr> m_segments;
// the mapping from the segment number to the
// storage location in the vector
std::map<int, int> m_number_to_location;

53
opm/parser/eclipse/EclipseState/Schedule/Well.cpp
View File

@@ -54,7 +54,7 @@ namespace Opm {
m_grid( grid ),
m_comporder(completionOrdering),
m_allowCrossFlow(allowCrossFlow),
m_segmentset(new DynamicState<SegmentSetPtr>(timeMap, SegmentSetPtr(new SegmentSet())))
m_segmentset(new DynamicState<SegmentSetConstPtr>(timeMap, SegmentSetPtr(new SegmentSet())))
{
m_name = name_;
m_creationTimeStep = creationTimeStep;
@@ -446,20 +446,22 @@ namespace Opm {
// the segments in the same range should share the same properties
const double volume_segment = (*new_segmentset)[location_end]->crossArea() * length_segment;
if ((*new_segmentset)[location_end]->volume() < 0.5 * meaningless_value) {
(*new_segmentset)[location_end]->setVolume(volume_segment);
}
// if ((*new_segmentset)[location_end]->volume() < 0.5 * meaningless_value) {
// (*new_segmentset)[location_end]->setVolume(volume_segment);
// }
for (int k = location_begin; k < location_end; ++k) {
SegmentPtr new_segment = std::make_shared<Segment>((*new_segmentset)[k]);
const double temp_length = length_outlet + (k - location_begin + 1) * length_segment;
(*new_segmentset)[k]->setLength(temp_length);
new_segment->setLength(temp_length);
const double temp_depth = depth_outlet + (k - location_begin + 1) * depth_segment;
(*new_segmentset)[k]->setDepth(temp_depth);
(*new_segmentset)[k]->setDataReady(true);
new_segment->setDepth(temp_depth);
new_segment->setDataReady(true);
if ((*new_segmentset)[k]->volume() < 0.5 * meaningless_value) {
(*new_segmentset)[k]->setVolume(volume_segment);
if (new_segment->volume() < 0.5 * meaningless_value) {
new_segment->setVolume(volume_segment);
}
new_segmentset->addSegment(new_segment);
}
break;
}
@@ -470,11 +472,13 @@ namespace Opm {
// this is for the segments specified individually while the volume is not specified.
for (int i = 1; i < new_segmentset->numberSegment(); ++i) {
if ((*new_segmentset)[i]->volume() < 0.5 * meaningless_value) {
SegmentPtr new_segment = std::make_shared<Segment>((*new_segmentset)[i]);
const int outlet_segment = (*new_segmentset)[i]->outletSegment();
const int outlet_location = new_segmentset->numberToLocation(outlet_segment);
const double segment_length = (*new_segmentset)[i]->length() - (*new_segmentset)[outlet_location]->length();
const double segment_volume = (*new_segmentset)[i]->crossArea() * segment_length;
(*new_segmentset)[i]->setVolume(segment_volume);
new_segment->setVolume(segment_volume);
new_segmentset->addSegment(new_segment);
}
}
@@ -482,18 +486,21 @@ namespace Opm {
} else {
throw std::logic_error("re-entering WELSEGS for a well is not supported yet!!.");
}
}
}
void Well::addSegmentSetINC(size_t time_step, const SegmentSetPtr new_segmentset, const bool first_time) {
// The following code only applies when no loop exist.
if (first_time) {
// update the information inside new_segmentset to be in ABS way
(*new_segmentset)[0]->setLength(new_segmentset->lengthTopSegment());
(*new_segmentset)[0]->setDepth(new_segmentset->depthTopSegment());
(*new_segmentset)[0]->setDataReady(true);
{
SegmentPtr new_top_segment = std::make_shared<Segment>((*new_segmentset)[0]);
new_top_segment->setLength(new_segmentset->lengthTopSegment());
new_top_segment->setDepth(new_segmentset->depthTopSegment());
new_top_segment->setDataReady(true);
new_segmentset->addSegment(new_top_segment);
}
bool all_ready;
do {
all_ready = true;
for (int i = 1; i < new_segmentset->numberSegment(); ++i) {
@@ -505,11 +512,13 @@ namespace Opm {
int outlet_location = new_segmentset->numberToLocation(outlet_segment);
if ((*new_segmentset)[outlet_location]->dataReady() == true) {
SegmentPtr new_segment = std::make_shared<Segment>((*new_segmentset)[i]);
const double temp_length = (*new_segmentset)[i]->length() + (*new_segmentset)[outlet_location]->length();
(*new_segmentset)[i]->setLength(temp_length);
new_segment->setLength(temp_length);
const double temp_depth = (*new_segmentset)[i]->depth() + (*new_segmentset)[outlet_location]->depth();
(*new_segmentset)[i]->setDepth(temp_depth);
(*new_segmentset)[i]->setDataReady(true);
new_segment->setDepth(temp_depth);
new_segment->setDataReady(true);
new_segmentset->addSegment(new_segment);
break;
}
@@ -522,11 +531,13 @@ namespace Opm {
}
if ((*new_segmentset)[outlet_location]->dataReady() == true) {
SegmentPtr new_segment = std::make_shared<Segment>((*new_segmentset)[current_location]);
const double temp_length = (*new_segmentset)[current_location]->length() + (*new_segmentset)[outlet_location]->length();
(*new_segmentset)[current_location]->setLength(temp_length);
new_segment->setLength(temp_length);
const double temp_depth = (*new_segmentset)[current_location]->depth() + (*new_segmentset)[outlet_location]->depth();
(*new_segmentset)[current_location]->setDepth(temp_depth);
(*new_segmentset)[current_location]->setDataReady(true);
new_segment->setDepth(temp_depth);
new_segment->setDataReady(true);
new_segmentset->addSegment(new_segment);
break;
}
}

2
opm/parser/eclipse/EclipseState/Schedule/Well.hpp
View File

@@ -157,7 +157,7 @@ namespace Opm {
// WELSEGS DATA - for mutli-segment wells
// flag indicating if the well is a multi-segment well
std::shared_ptr<DynamicState<SegmentSetPtr>> m_segmentset;
std::shared_ptr<DynamicState<SegmentSetConstPtr>> m_segmentset;
};
typedef std::shared_ptr<Well> WellPtr;
typedef std::shared_ptr<const Well> WellConstPtr;