Go to the documentation of this file.00001
00002
00003
00004
00005 #include <assert.h>
00006
00007 #include <iostream>
00008 #include <cmath>
00009 #include <list>
00010 #include <algorithm>
00011
00012 #include <stdair/stdair_rm_types.hpp>
00013 #include <stdair/bom/LegCabin.hpp>
00014 #include <stdair/bom/VirtualClassStruct.hpp>
00015
00016 #include <rmol/bom/Emsr.hpp>
00017 #include <rmol/bom/EmsrUtils.hpp>
00018
00019 namespace RMOL {
00020
00021 void Emsr::heuristicOptimisationByEmsrA (stdair::LegCabin& ioLegCabin) {
00022 stdair::VirtualClassList_T& lVirtualClassList =
00023 ioLegCabin.getVirtualClassList ();
00024 const stdair::CabinCapacity_T& lCabinCapacity =
00025 ioLegCabin.getOfferedCapacity();
00026
00032 stdair::VirtualClassList_T::iterator itVC =lVirtualClassList.begin();
00033 assert (itVC != lVirtualClassList.end());
00034
00035 stdair::VirtualClassStruct& lFirstVC = *itVC;
00036 lFirstVC.setCumulatedBookingLimit (lCabinCapacity);
00037 ++itVC;
00038 for (; itVC != lVirtualClassList.end(); ++itVC) {
00039 stdair::VirtualClassStruct& lNextVC = *itVC;
00040
00041
00042 stdair::ProtectionLevel_T lProtectionLevel = 0.0;
00043
00044 for(stdair::VirtualClassList_T::iterator itHigherVC =
00045 lVirtualClassList.begin(); itHigherVC != itVC; ++itHigherVC) {
00046 stdair::VirtualClassStruct& lHigherVC = *itHigherVC;
00047 const double lPartialProtectionLevel =
00048 EmsrUtils::computeProtectionLevel (lHigherVC, lNextVC);
00049 lProtectionLevel += lPartialProtectionLevel;
00050 }
00051 stdair::VirtualClassList_T::iterator itCurrentVC = itVC; --itCurrentVC;
00052 stdair::VirtualClassStruct& lCurrentVC = *itCurrentVC;
00053 lCurrentVC.setCumulatedProtection (lProtectionLevel);
00054
00055
00056 const double lBookingLimit = lCabinCapacity - lProtectionLevel;
00057
00058
00059 lNextVC.setCumulatedBookingLimit (lBookingLimit);
00060 }
00061 }
00062
00063
00064 void Emsr::heuristicOptimisationByEmsrB (stdair::LegCabin& ioLegCabin) {
00065 stdair::VirtualClassList_T& lVirtualClassList =
00066 ioLegCabin.getVirtualClassList ();
00067 const stdair::CabinCapacity_T& lCabinCapacity =
00068 ioLegCabin.getOfferedCapacity();
00069
00075 stdair::VirtualClassList_T::iterator itVC =lVirtualClassList.begin();
00076 assert (itVC != lVirtualClassList.end());
00077
00078 stdair::VirtualClassStruct& lFirstVC = *itVC;
00079 lFirstVC.setCumulatedBookingLimit (lCabinCapacity);
00080 ++itVC;
00081 stdair::VirtualClassStruct lAggregatedVC = lFirstVC;
00082 for (; itVC != lVirtualClassList.end(); ++itVC) {
00083 stdair::VirtualClassStruct& lNextVC = *itVC;
00084
00085
00086
00087 const stdair::ProtectionLevel_T lProtectionLevel =
00088 EmsrUtils::computeProtectionLevel (lAggregatedVC, lNextVC);
00089
00090
00091 stdair::VirtualClassList_T::iterator itCurrentVC = itVC; --itCurrentVC;
00092 stdair::VirtualClassStruct& lCurrentVC = *itCurrentVC;
00093 lCurrentVC.setCumulatedProtection (lProtectionLevel);
00094
00095
00096 const double lBookingLimit = lCabinCapacity - lProtectionLevel;
00097
00098
00099 lNextVC.setCumulatedBookingLimit (lBookingLimit);
00100
00101
00102 EmsrUtils::computeAggregatedVirtualClass (lAggregatedVC, lNextVC);
00103
00104 }
00105 }
00106
00107
00108 void Emsr::heuristicOptimisationByEmsr (stdair::LegCabin& ioLegCabin) {
00109 stdair::VirtualClassList_T& lVirtualClassList =
00110 ioLegCabin.getVirtualClassList ();
00111 const stdair::CabinCapacity_T& lCapacity = ioLegCabin.getOfferedCapacity();
00112 ioLegCabin.emptyBidPriceVector();
00113 stdair::BidPriceVector_T& lBidPriceVector =
00114 ioLegCabin.getBidPriceVector();
00115
00116
00117 const int lCabinCapacity = static_cast<const int> (lCapacity);
00118
00119
00120 stdair::EmsrValueList_T lEmsrValueList;
00121
00127 for (stdair::VirtualClassList_T::iterator itVC = lVirtualClassList.begin();
00128 itVC != lVirtualClassList.end(); ++itVC) {
00129 stdair::VirtualClassStruct& lCurrentVC = *itVC;
00130 for (int k = 1; k <= lCabinCapacity; ++k) {
00131 const double emsrValue = EmsrUtils::computeEmsrValue (k, lCurrentVC);
00132 lEmsrValueList.push_back(emsrValue);
00133 }
00134 }
00135
00136
00137 std::sort(lEmsrValueList.rbegin(), lEmsrValueList.rend());
00138
00139
00140 const int lEmsrValueListSize = lEmsrValueList.size();
00141 assert (lEmsrValueListSize >= lCabinCapacity);
00142
00143
00144 stdair::EmsrValueList_T::const_iterator itCurrentValue =
00145 lEmsrValueList.begin();
00146 for (int j = 0; j < lCabinCapacity; ++j, ++itCurrentValue) {
00147 const double lBidPrice = *itCurrentValue;
00148 lBidPriceVector.push_back (lBidPrice);
00149 }
00150 lEmsrValueList.clear();
00151
00152
00153 if (lVirtualClassList.size() > 1) {
00154 int lCapacityIndex = 0;
00155 for (stdair::VirtualClassList_T::iterator itVC =lVirtualClassList.begin();
00156 itVC != lVirtualClassList.end();) {
00157 stdair::VirtualClassStruct& lCurrentVC = *itVC;
00158 if (itVC != lVirtualClassList.end()) {
00159 ++itVC;
00160 }
00161 stdair::VirtualClassStruct& lNextVC = *itVC;
00162 const stdair::Yield_T lNextYield = lNextVC.getYield();
00163 while ((lCapacityIndex < lCabinCapacity)
00164 && (lBidPriceVector.at(lCapacityIndex) > lNextYield)) {
00165 ++lCapacityIndex;
00166 }
00167 lCurrentVC.setCumulatedProtection (lCapacityIndex);
00168 lNextVC.setCumulatedBookingLimit (lCapacity - lCapacityIndex);
00169 }
00170 }
00171 }
00172
00173 }