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

Merge pull request #1381 from akva2/noecl_flush

Browse Source 
More serialization preparation
This commit is contained in:
Joakim Hove 2020-01-02 11:50:03 +01:00 committed by GitHub
commit af477900b9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 533 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
opm/parser/eclipse/EclipseState/Schedule/Group/Group.hpp
View File

@ -162,12 +162,35 @@ struct ProductionControls {
};
Group();
Group(const std::string& group_name, std::size_t insert_index_arg, std::size_t init_step_arg, double udq_undefined_arg, const UnitSystem& unit_system);
Group(const std::string& gname,
std::size_t insert_idx,
std::size_t initstep,
double udqUndef,
const UnitSystem& units,
GroupType gtype,
double groupEF,
bool transferGroupEF,
int vfp,
const std::string& parent,
const IOrderSet<std::string>& well,
const IOrderSet<std::string>& group,
const GroupInjectionProperties& injProps,
const GroupProductionProperties& prodProps);
bool defined(std::size_t timeStep) const;
std::size_t insert_index() const;
std::size_t initStep() const;
double udqUndefined() const;
const UnitSystem& units() const;
const std::string& name() const;
GroupType type() const;
int getGroupNetVFPTable() const;
const IOrderSet<std::string>& iwells() const;
const IOrderSet<std::string>& igroups() const;
bool updateNetVFPTable(int vfp_arg);
bool update_gefac(double gefac, bool transfer_gefac);
@ -203,6 +226,9 @@ struct ProductionControls {
Phase injection_phase() const;
bool has_control(ProductionCMode control) const;
bool has_control(InjectionCMode control) const;
bool operator==(const Group& data) const;
private:
bool hasType(GroupType gtype) const;
void addType(GroupType new_gtype);

9
opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.hpp
View File

@ -44,6 +44,14 @@ 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(int segmentNumber, int branchNumber, int outlegSegment,
const std::vector<int>& inletSegments,
double totalLength, double depth, double internalDiameter,
double roughness, double crossArea, double volume,
bool dataReady, SegmentType segmentType,
std::shared_ptr<SpiralICD> spiralICD,
std::shared_ptr<Valve> valv);
int segmentNumber() const;
int branchNumber() const;
int outletSegment() const;
@ -71,6 +79,7 @@ namespace Opm {
void updateSpiralICD(const SpiralICD& spiral_icd);
const std::shared_ptr<SpiralICD>& spiralICD() const;
const std::shared_ptr<Valve>& getValve() const;
void updateValve(const Valve& valve, const double segment_length);

14
opm/parser/eclipse/EclipseState/Schedule/MSW/SpiralICD.hpp
View File

@ -39,7 +39,19 @@ namespace Opm {
SHUT
};
SpiralICD();
explicit SpiralICD(const DeckRecord& record);
SpiralICD(double strength,
double length,
double densityCalibration,
double viscosityCalibration,
double criticalValue,
double widthTransitionRegion,
double maxViscosityRatio,
int methodFlowScaling,
double maxAbsoluteRate,
Status status,
double scalingFactor);
// the function will return a map
// [
@ -62,6 +74,8 @@ namespace Opm {
void updateScalingFactor(const double segment_length, const double completion_length);
double scalingFactor() const;
bool operator==(const SpiralICD& data) const;
private:
double m_strength;
double m_length;

15
opm/parser/eclipse/EclipseState/Schedule/MSW/Valve.hpp
View File

@ -38,7 +38,16 @@ namespace Opm {
SHUT
};
Valve();
explicit Valve(const DeckRecord& record);
Valve(double conFlowCoeff,
double conCrossA,
double conMaxCrossA,
double pipeAddLength,
double pipeDiam,
double pipeRough,
double pipeCrossA,
Status stat);
// the function will return a map
// [
@ -67,9 +76,11 @@ namespace Opm {
void setPipeRoughness(const double rou);
void setPipeCrossArea(const double area);
bool operator==(const Valve& data) const;
private:
const double m_con_flow_coeff;
const double m_con_cross_area;
double m_con_flow_coeff;
double m_con_cross_area;
double m_con_max_cross_area;
double m_pipe_additional_length;

12
opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp
View File

@ -62,6 +62,15 @@ namespace Opm {
WellSegments() = default;
WellSegments(const std::string& wname,
double depthTopSeg,
double lengthTopSeg,
double volumeTopSeg,
LengthDepth lenDepType,
CompPressureDrop compDrop,
MultiPhaseModel multiPhase,
const std::vector<Segment>& segments,
const std::map<int,int>& segmentNumberIdx);
const std::string& wellName() const;
int size() const;
@ -70,6 +79,7 @@ namespace Opm {
double volumeTopSegment() const;
CompPressureDrop compPressureDrop() const;
LengthDepth lengthDepthType() const;
MultiPhaseModel multiPhaseModel() const;
// mapping the segment number to the index in the vector of segments
@ -92,6 +102,8 @@ namespace Opm {
// it returns true if there is no error encountered during the update
bool updateWSEGSICD(const std::vector<std::pair<int, SpiralICD> >& sicd_pairs);
const std::vector<Segment>& segments() const;
const std::map<int,int>& segmentNumberIndex() const;
bool updateWSEGVALV(const std::vector<std::pair<int, Valve> >& valve_pairs);

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

@ -370,6 +370,7 @@ public:
};
Well();
Well(const std::string& wname,
const std::string& gname,
std::size_t init_step,
@ -383,6 +384,35 @@ public:
const UnitSystem& unit_system,
double udq_undefined);
Well(const std::string& wname,
const std::string& gname,
std::size_t init_step,
std::size_t insert_index,
int headI,
int headJ,
double ref_depth,
const Phase& phase_arg,
Connection::Order ordering,
const UnitSystem& unit_system,
double udq_undefined,
Status status,
double drainageRadius,
bool allowCrossFlow,
bool automaticShutIn,
bool isProducer,
const WellGuideRate& guideRate,
double efficiencyFactor,
double solventFraction,
bool prediction_mode,
std::shared_ptr<const WellEconProductionLimits> econLimits,
std::shared_ptr<const WellFoamProperties> foamProperties,
std::shared_ptr<const WellPolymerProperties> polymerProperties,
std::shared_ptr<const WellTracerProperties> tracerProperties,
std::shared_ptr<WellConnections> connections,
std::shared_ptr<const WellProductionProperties> production,
std::shared_ptr<const WellInjectionProperties> injection,
std::shared_ptr<const WellSegments> segments);
bool isMultiSegment() const;
bool isAvailableForGroupControl() const;
double getGuideRate() const;
@ -482,6 +512,13 @@ public:
int vfp_table_number() const;
double alq_value() const;
double temperature() const;
const UnitSystem& units() const;
double udqUndefined() const;
bool hasSegments() const;
const WellGuideRate& wellGuideRate() const;
bool operator==(const Well& data) const;
private:
std::string wname;
std::string group_name;

26
opm/parser/eclipse/EclipseState/Util/IOrderSet.hpp
View File

@ -46,19 +46,24 @@ namespace Opm {
template <typename T>
class IOrderSet {
public:
using storage_type = typename std::vector<T>;
using index_type = typename std::unordered_set<T>;
using const_iter_type = typename storage_type::const_iterator;
private:
index_type index;
index_type m_index;
storage_type m_data;
public:
IOrderSet() = default;
IOrderSet(const index_type& index, const storage_type& data)
: m_index(index)
, m_data(data)
{}
std::size_t size() const {
return this->index.size();
return this->m_index.size();
}
bool empty() const {
@ -66,7 +71,7 @@ public:
}
std::size_t count(const T& value) const {
return this->index.count(value);
return this->m_index.count(value);
}
bool contains(const T& value) const {
@ -77,7 +82,7 @@ public:
if (this->contains(value))
return false;
this->index.insert(value);
this->m_index.insert(value);
this->m_data.push_back(value);
return true;
}
@ -86,7 +91,7 @@ public:
if (!this->contains(value))
return 0;
this->index.erase(value);
this->m_index.erase(value);
auto data_iter = std::find(this->m_data.begin(), this->m_data.end(), value);
this->m_data.erase(data_iter);
return 1;
@ -108,6 +113,15 @@ public:
return this->m_data;
};
const index_type& index() const {
return this->m_index;
};
bool operator==(const IOrderSet<T>& data) const {
return this->index() == data.index() &&
this->data() == data.data();
}
};
}

1
opm/parser/eclipse/Units/Dimension.hpp
View File

@ -30,6 +30,7 @@ namespace Opm {
Dimension(const std::string& name, double SIfactor, double SIoffset = 0.0);
double getSIScaling() const;
double getSIScalingRaw() const;
double getSIOffset() const;
double convertRawToSi(double rawValue) const;

4
opm/parser/eclipse/Units/UnitSystem.hpp
View File

@ -78,6 +78,9 @@ namespace Opm {
explicit UnitSystem(UnitType unit = UnitType::UNIT_TYPE_METRIC);
explicit UnitSystem(const std::string& deck_name);
UnitSystem(const std::string& name, UnitType unit,
const std::map<std::string,Dimension>& dimensions,
size_t use_count);
const std::string& getName() const;
UnitType getType() const;
@ -88,6 +91,7 @@ namespace Opm {
const Dimension& getDimension(const std::string& dimension) const;
bool hasDimension(const std::string& dimension) const;
bool equal(const UnitSystem& other) const;
const std::map<std::string,Dimension>& getDimensions() const;
bool operator==( const UnitSystem& ) const;
bool operator!=( const UnitSystem& ) const;

78
src/opm/parser/eclipse/EclipseState/Schedule/Group/Group.cpp
View File

@ -25,6 +25,11 @@
namespace Opm {
Group::Group()
: Group("", 0, 0, 0.0, UnitSystem())
{
}
Group::Group(const std::string& name, std::size_t insert_index_arg, std::size_t init_step_arg, double udq_undefined_arg, const UnitSystem& unit_system_arg) :
m_name(name),
m_insert_index(insert_index_arg),
@ -41,10 +46,57 @@ Group::Group(const std::string& name, std::size_t insert_index_arg, std::size_t
this->parent_group = "FIELD";
}
Group::Group(const std::string& gname,
std::size_t insert_idx,
std::size_t initstep,
double udqUndef,
const UnitSystem& units,
GroupType gtype,
double groupEF,
bool transferGroupEF,
int vfp,
const std::string& parentName,
const IOrderSet<std::string>& well,
const IOrderSet<std::string>& group,
const GroupInjectionProperties& injProps,
const GroupProductionProperties& prodProps) :
m_name(gname),
m_insert_index(insert_idx),
init_step(initstep),
udq_undefined(udqUndef),
unit_system(units),
group_type(gtype),
gefac(groupEF),
transfer_gefac(transferGroupEF),
vfp_table(vfp),
parent_group(parentName),
m_wells(well),
m_groups(group),
injection_properties(injProps),
production_properties(prodProps)
{
}
std::size_t Group::insert_index() const {
return this->m_insert_index;
}
std::size_t Group::initStep() const {
return this->init_step;
}
double Group::udqUndefined() const {
return this->udq_undefined;
}
const UnitSystem& Group::units() const {
return this->unit_system;
}
Group::GroupType Group::type() const {
return this->group_type;
}
bool Group::defined(size_t timeStep) const {
return (timeStep >= this->init_step);
}
@ -65,6 +117,14 @@ int Group::getGroupNetVFPTable() const {
return this->vfp_table;
}
const IOrderSet<std::string>& Group::iwells() const {
return m_wells;
}
const IOrderSet<std::string>& Group::igroups() const {
return m_groups;
}
bool Group::updateNetVFPTable(int vfp_arg) {
if (this->vfp_table != vfp_arg) {
this->vfp_table = vfp_arg;
@ -493,4 +553,22 @@ Group::GuideRateTarget Group::GuideRateTargetFromString( const std::string& stri
return GuideRateTarget::NO_GUIDE_RATE;
}
bool Group::operator==(const Group& data) const
{
return this->name() == data.name() &&
this->insert_index() == data.insert_index() &&
this->initStep() == data.initStep() &&
this->udqUndefined() == data.udqUndefined() &&
this->units() == data.units() &&
this->type() == data.type() &&
this->getGroupEfficiencyFactor() == data.getGroupEfficiencyFactor() &&
this->getTransferGroupEfficiencyFactor() == data.getTransferGroupEfficiencyFactor() &&
this->getGroupNetVFPTable() == data.getGroupNetVFPTable() &&
this->parent() == data.parent() &&
this->iwells() == data.iwells() &&
this->igroups() == data.igroups() &&
this->injectionProperties() == data.injectionProperties() &&
this->productionProperties() == data.productionProperties();
}
}

29
src/opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.cpp
View File

@ -56,6 +56,31 @@ namespace Opm {
{
}
Segment::Segment(int segmentNum, int branchNum, int outletSeg,
const std::vector<int>& inletSegs,
double totalLen, double dept, double internalDiam,
double rough, double crossA, double vol,
bool dr, SegmentType segment,
std::shared_ptr<SpiralICD> spiralIcd,
std::shared_ptr<Valve> valv)
: m_segment_number(segmentNum),
m_branch(branchNum),
m_outlet_segment(outletSeg),
m_inlet_segments(inletSegs),
m_total_length(totalLen),
m_depth(dept),
m_internal_diameter(internalDiam),
m_roughness(rough),
m_cross_area(crossA),
m_volume(vol),
m_data_ready(dr),
m_segment_type(segment),
m_spiral_icd(spiralIcd),
m_valve(valv)
{
}
int Segment::segmentNumber() const {
return m_segment_number;
}
@ -196,4 +221,8 @@ namespace Opm {
return m_valve.get();
}
const std::shared_ptr<Valve>& Segment::getValve() const {
return m_valve;
}
}

46
src/opm/parser/eclipse/EclipseState/Schedule/MSW/SpiralICD.cpp
View File

@ -28,6 +28,37 @@
namespace Opm {
SpiralICD::SpiralICD()
: SpiralICD(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0, 0.0, Status::SHUT, 1.0)
{
}
SpiralICD::SpiralICD(double strength,
double length,
double densityCalibration,
double viscosityCalibration,
double criticalValue,
double widthTransitionRegion,
double maxViscosityRatio,
int flowScaling,
double maxAbsoluteRate,
Status status,
double scalingFactor)
: m_strength(strength),
m_length(length),
m_density_calibration(densityCalibration),
m_viscosity_calibration(viscosityCalibration),
m_critical_value(criticalValue),
m_width_transition_region(widthTransitionRegion),
m_max_viscosity_ratio(maxViscosityRatio),
m_method_flow_scaling(flowScaling),
m_max_absolute_rate(maxAbsoluteRate),
m_status(status),
m_scaling_factor(scalingFactor)
{
}
SpiralICD::SpiralICD(const DeckRecord& record)
: m_strength(record.getItem("STRENGTH").getSIDouble(0)),
m_length(record.getItem("LENGTH").getSIDouble(0)),
@ -154,4 +185,19 @@ namespace Opm {
throw std::logic_error(" invalid method specified to calculate flow scaling factor for SICD");
}
}
bool SpiralICD::operator==(const SpiralICD& data) const {
return this->strength() == data.strength() &&
this->length() == data.length() &&
this->densityCalibration() == data.densityCalibration() &&
this->viscosityCalibration() == data.viscosityCalibration() &&
this->criticalValue() == data.criticalValue() &&
this->widthTransitionRegion() == data.widthTransitionRegion() &&
this->maxViscosityRatio() == data.maxViscosityRatio() &&
this->methodFlowScaling() == data.methodFlowScaling() &&
this->maxAbsoluteRate() == data.maxAbsoluteRate() &&
this->status() == data.status() &&
this->scalingFactor() == data.scalingFactor();
}
}

35
src/opm/parser/eclipse/EclipseState/Schedule/MSW/Valve.cpp
View File

@ -26,6 +26,30 @@
namespace Opm {
Valve::Valve()
: Valve(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Status::SHUT)
{
}
Valve::Valve(double conFlowCoeff,
double conCrossA,
double conMaxCrossA,
double pipeAddLength,
double pipeDiam,
double pipeRough,
double pipeCrossA,
Status stat)
: m_con_flow_coeff(conFlowCoeff)
, m_con_cross_area(conCrossA)
, m_con_max_cross_area(conMaxCrossA)
, m_pipe_additional_length(pipeAddLength)
, m_pipe_diameter(pipeDiam)
, m_pipe_roughness(pipeRough)
, m_pipe_cross_area(pipeCrossA)
, m_status(stat)
{
}
Valve::Valve(const DeckRecord& record)
: m_con_flow_coeff(record.getItem("CV").get<double>(0))
, m_con_cross_area(record.getItem("AREA").get<double>(0))
@ -140,4 +164,15 @@ namespace Opm {
void Valve::setPipeAdditionalLength(const double length) {
m_pipe_additional_length = length;
}
bool Valve::operator==(const Valve& data) const {
return this->conFlowCoefficient() == data.conFlowCoefficient() &&
this->conCrossArea() == data.conCrossArea() &&
this->conMaxCrossArea() == data.conMaxCrossArea() &&
this->pipeAdditionalLength() == data.pipeAdditionalLength() &&
this->pipeDiameter() == data.pipeDiameter() &&
this->pipeRoughness() == data.pipeRoughness() &&
this->pipeCrossArea() == data.pipeCrossArea() &&
this->status() == data.status();
}
}

35
src/opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.cpp
View File

@ -36,6 +36,27 @@
namespace Opm {
WellSegments::WellSegments(const std::string& wname,
double depthTopSeg,
double lengthTopSeg,
double volumeTopSeg,
LengthDepth lenDepType,
CompPressureDrop compDrop,
MultiPhaseModel multiPhase,
const std::vector<Segment>& segments,
const std::map<int,int>& segmentNumberIdx)
: m_well_name(wname)
, m_depth_top(depthTopSeg)
, m_length_top(lengthTopSeg)
, m_volume_top(volumeTopSeg)
, m_length_depth_type(lenDepType)
, m_comp_pressure_drop(compDrop)
, m_multiphase_model(multiPhase)
, m_segments(segments)
, segment_number_to_index(segmentNumberIdx)
{
}
const std::string& WellSegments::wellName() const {
return m_well_name;
}
@ -560,6 +581,18 @@ WellSegments::MultiPhaseModel WellSegments::MultiPhaseModelFromString(const std:
} else {
throw std::invalid_argument("Unknown enum string_value: " + string_value + " for MultiPhaseModel");
}
}
WellSegments::LengthDepth WellSegments::lengthDepthType() const {
return m_length_depth_type;
}
const std::vector<Segment>& WellSegments::segments() const {
return m_segments;
}
const std::map<int,int>& WellSegments::segmentNumberIndex() const {
return segment_number_to_index;
}
}
}

131
src/opm/parser/eclipse/EclipseState/Schedule/Well/Well.cpp
View File

@ -72,6 +72,25 @@ namespace {
}
Well::Well() :
init_step(0),
insert_index(0),
headI(0),
headJ(0),
ref_depth(0.0),
phase(Phase::OIL),
ordering(Connection::Order::DEPTH),
udq_undefined(0.0),
status(Status::STOP),
drainage_radius(0.0),
allow_cross_flow(false),
automatic_shutin(false),
producer(false),
efficiency_factor(0.0),
solvent_fraction(0.0)
{
}
Well::Well(const std::string& wname_arg,
const std::string& gname,
@ -117,6 +136,65 @@ Well::Well(const std::string& wname_arg,
this->updateProduction(p);
}
Well::Well(const std::string& wname_arg,
const std::string& gname,
std::size_t init_step_arg,
std::size_t insert_index_arg,
int headI_arg,
int headJ_arg,
double ref_depth_arg,
const Phase& phase_arg,
Connection::Order ordering_arg,
const UnitSystem& units,
double udq_undefined_arg,
Status status_arg,
double drainageRadius,
bool allowCrossFlow,
bool automaticShutIn,
bool isProducer,
const WellGuideRate& guideRate,
double efficiencyFactor,
double solventFraction,
bool predictionMode,
std::shared_ptr<const WellEconProductionLimits> econLimits,
std::shared_ptr<const WellFoamProperties> foamProperties,
std::shared_ptr<const WellPolymerProperties> polymerProperties,
std::shared_ptr<const WellTracerProperties> tracerProperties,
std::shared_ptr<WellConnections> connections_arg,
std::shared_ptr<const WellProductionProperties> production_arg,
std::shared_ptr<const WellInjectionProperties> injection_arg,
std::shared_ptr<const WellSegments> segments_arg) :
wname(wname_arg),
group_name(gname),
init_step(init_step_arg),
insert_index(insert_index_arg),
headI(headI_arg),
headJ(headJ_arg),
ref_depth(ref_depth_arg),
phase(phase_arg),
ordering(ordering_arg),
unit_system(units),
udq_undefined(udq_undefined_arg),
status(status_arg),
drainage_radius(drainageRadius),
allow_cross_flow(allowCrossFlow),
automatic_shutin(automaticShutIn),
producer(isProducer),
guide_rate(guideRate),
efficiency_factor(efficiencyFactor),
solvent_fraction(solventFraction),
prediction_mode(predictionMode),
econ_limits(econLimits),
foam_properties(foamProperties),
polymer_properties(polymerProperties),
tracer_properties(tracerProperties),
connections(connections_arg),
production(production_arg),
injection(injection_arg),
segments(segments_arg)
{
}
bool Well::updateEfficiencyFactor(double efficiency_factor_arg) {
if (this->efficiency_factor != efficiency_factor_arg) {
this->efficiency_factor = efficiency_factor_arg;
@ -1057,4 +1135,57 @@ Well::GuideRateTarget Well::GuideRateTargetFromString( const std::string& string
else
throw std::invalid_argument("Unknown enum state string: " + stringValue );
}
const Well::WellGuideRate& Well::wellGuideRate() const {
return guide_rate;
}
const UnitSystem& Well::units() const {
return unit_system;
}
double Well::udqUndefined() const {
return udq_undefined;
}
bool Well::hasSegments() const {
return segments != nullptr;
}
bool Well::operator==(const Well& data) const {
if (this->hasSegments() != data.hasSegments()) {
return false;
}
if (this->hasSegments() && (this->getSegments() != data.getSegments())) {
return false;
}
return this->name() == data.name() &&
this->groupName() == data.groupName() &&
this->firstTimeStep() == data.firstTimeStep() &&
this->seqIndex() == data.seqIndex() &&
this->getHeadI() == data.getHeadI() &&
this->getHeadJ() == data.getHeadJ() &&
this->getRefDepth() == data.getRefDepth() &&
this->getPreferredPhase() == data.getPreferredPhase() &&
this->getWellConnectionOrdering() == data.getWellConnectionOrdering() &&
this->units() == data.units() &&
this->udqUndefined() == data.udqUndefined() &&
this->getStatus() == data.getStatus() &&
this->getDrainageRadius() == data.getDrainageRadius() &&
this->getAllowCrossFlow() == data.getAllowCrossFlow() &&
this->getAutomaticShutIn() == data.getAutomaticShutIn() &&
this->isProducer() == data.isProducer() &&
this->wellGuideRate() == data.wellGuideRate() &&
this->getEfficiencyFactor() == data.getEfficiencyFactor() &&
this->getSolventFraction() == data.getSolventFraction() &&
this->getEconLimits() == data.getEconLimits() &&
this->getFoamProperties() == data.getFoamProperties() &&
this->getTracerProperties() == data.getTracerProperties() &&
this->getProductionProperties() == data.getProductionProperties() &&
this->getInjectionProperties() == data.getInjectionProperties();
}
}

4
src/opm/parser/eclipse/Units/Dimension.cpp
View File

@ -51,6 +51,10 @@ namespace Opm {
return m_SIfactor;
}
double Dimension::getSIScalingRaw() const {
return m_SIfactor;
}
double Dimension::getSIOffset() const {
return m_SIoffset;
}

41
src/opm/parser/eclipse/Units/UnitSystem.cpp
View File

@ -826,6 +826,41 @@ namespace {
};
}
UnitSystem::UnitSystem(const std::string& name, UnitType unit,
const std::map<std::string,Dimension>& dimensions,
size_t use_count)
: m_name(name)
, m_unittype(unit)
, m_dimensions(dimensions)
, m_use_count(use_count)
{
switch(unit) {
case(UnitType::UNIT_TYPE_METRIC):
this->initMETRIC();
break;
case(UnitType::UNIT_TYPE_FIELD):
this->initFIELD();
break;
case(UnitType::UNIT_TYPE_LAB):
this->initLAB();
break;
case(UnitType::UNIT_TYPE_PVT_M):
this->initPVT_M();
break;
case(UnitType::UNIT_TYPE_INPUT):
this->initINPUT();
break;
default:
throw std::runtime_error("Tried to construct UnitSystem with unknown unit family.");
break;
};
}
void UnitSystem::initINPUT() {
this->m_name = "Input";
this->measure_table_from_si = to_input;
@ -1048,7 +1083,7 @@ namespace {
case(UnitType::UNIT_TYPE_LAB): return "LAB";
case(UnitType::UNIT_TYPE_PVT_M): return "PVT-M";
default:
throw std::invalid_argument("No valuid deckname could be inferred");
throw std::invalid_argument("No valid deckname could be inferred");
}
}
@ -1222,5 +1257,9 @@ namespace {
return system;
}
const std::map<std::string,Dimension>& UnitSystem::getDimensions() const {
return m_dimensions;
}
}