$treeview $search $mathjax
00001 // ////////////////////////////////////////////////////////////////////// 00002 // Import section 00003 // ////////////////////////////////////////////////////////////////////// 00004 // C 00005 #include <assert.h> 00006 // STL 00007 #include <iostream> 00008 #include <cmath> 00009 #include <list> 00010 #include <algorithm> 00011 // StdAir 00012 #include <stdair/stdair_rm_types.hpp> 00013 #include <stdair/bom/LegCabin.hpp> 00014 #include <stdair/bom/VirtualClassStruct.hpp> 00015 // RMOL 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 // Initialise the protection for class/bucket j. 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 // Compute the booking limit for the class/bucket j+1 (can be negative). 00056 const double lBookingLimit = lCabinCapacity - lProtectionLevel; 00057 00058 // Set the booking limit for class/bucket j+1. 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 // Compute the protection level for the aggregated class/bucket 00086 // using the Little-Wood formular. 00087 const stdair::ProtectionLevel_T lProtectionLevel = 00088 EmsrUtils::computeProtectionLevel (lAggregatedVC, lNextVC); 00089 00090 // Set the protection level for class/bucket j. 00091 stdair::VirtualClassList_T::iterator itCurrentVC = itVC; --itCurrentVC; 00092 stdair::VirtualClassStruct& lCurrentVC = *itCurrentVC; 00093 lCurrentVC.setCumulatedProtection (lProtectionLevel); 00094 00095 // Compute the booking limit for class/bucket j+1 (can be negative). 00096 const double lBookingLimit = lCabinCapacity - lProtectionLevel; 00097 00098 // Set the booking limit for class/bucket j+1. 00099 lNextVC.setCumulatedBookingLimit (lBookingLimit); 00100 00101 // Compute the aggregated class/bucket of classes/buckets 1,..,j. 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 // Cabin capacity in integer. 00117 const int lCabinCapacity = static_cast<const int> (lCapacity); 00118 00119 // List of all EMSR values. 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 // Sort the EMSR values from high to low. 00137 std::sort(lEmsrValueList.rbegin(), lEmsrValueList.rend()); 00138 00139 // Sanity check 00140 const int lEmsrValueListSize = lEmsrValueList.size(); 00141 assert (lEmsrValueListSize >= lCabinCapacity); 00142 00143 // Copy the EMSR sorted values to the BPV. 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 // Build the protection levels and booking limits. 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 }