9 #include <stdair/basic/BasConst_General.hpp>
10 #include <stdair/basic/BasConst_Inventory.hpp>
11 #include <stdair/basic/RandomGeneration.hpp>
12 #include <stdair/bom/BomManager.hpp>
13 #include <stdair/bom/FlightDate.hpp>
14 #include <stdair/bom/LegDate.hpp>
15 #include <stdair/bom/SegmentDate.hpp>
16 #include <stdair/bom/LegCabin.hpp>
17 #include <stdair/bom/SegmentCabin.hpp>
18 #include <stdair/bom/GuillotineBlock.hpp>
19 #include <stdair/bom/BookingClass.hpp>
20 #include <stdair/service/Logger.hpp>
36 const stdair::DateTime_T& iEventTime) {
38 const stdair::Date_T& lEventDate = iEventTime.date();
39 stdair::Date_T lRefDate (2012, boost::gregorian::Jan, 01);
42 bool isSucceeded =
true;
43 const stdair::SegmentDateList_T& lSDList =
44 stdair::BomManager::getList<stdair::SegmentDate> (ioFlightDate);
45 for (stdair::SegmentDateList_T::const_iterator itSD = lSDList.begin();
46 itSD != lSDList.end(); ++itSD) {
47 stdair::SegmentDate* lSD_ptr = *itSD;
48 assert (lSD_ptr != NULL);
50 const stdair::Date_T& lBoardingDate = lSD_ptr->getBoardingDate();
51 const stdair::DateOffset_T lSegmentDateOffset =
52 lBoardingDate - lEventDate;
53 const stdair::DTD_T lSegmentDTD = lSegmentDateOffset.days();
58 stdair::DCPList_T lDCPList;
60 if (lEventDate < lRefDate) {
67 const stdair::SegmentCabinList_T& lSCList =
68 stdair::BomManager::getList<stdair::SegmentCabin> (*lSD_ptr);
69 for (stdair::SegmentCabinList_T::const_iterator itSC = lSCList.begin();
70 itSC != lSCList.end(); ++itSC) {
71 stdair::SegmentCabin* lSC_ptr = *itSC;
72 assert (lSC_ptr != NULL);
79 if (isForecasted ==
false) {
91 const stdair::DCPList_T& iDCPList,
92 const stdair::Date_T& iEventDate) {
94 stdair::NbOfSegments_T lNbOfDepartedSegments =
97 if (lNbOfDepartedSegments > 52) lNbOfDepartedSegments = 52;
100 STDAIR_LOG_DEBUG (
"Nb of similar departed segments: "
101 << lNbOfDepartedSegments);
106 stdair::DCPList_T::const_iterator itDCP = iDCPList.begin();
107 assert (itDCP != iDCPList.end());
108 const stdair::DCP_T& lCurrentDTD = *itDCP;
109 if (iDCPList.size() == 1 || lNbOfDepartedSegments < 2) {
110 setRemainingDemandForecastToZero (ioSegmentCabin);
116 const stdair::BookingClassList_T& lBCList =
117 stdair::BomManager::getList<stdair::BookingClass> (ioSegmentCabin);
118 for (stdair::BookingClassList_T::const_iterator itBC = lBCList.begin();
119 itBC != lBCList.end(); ++itBC) {
120 stdair::BookingClass* lBC_ptr = *itBC;
121 assert (lBC_ptr != NULL);
122 std::vector<stdair::NbOfRequests_T> lUncDemandVector (lNbOfDepartedSegments, 0.0);
123 bool insertionSucceeded = lBkgClassUncDemMap.insert
125 value_type (lBC_ptr, lUncDemandVector)).second;
126 assert (insertionSucceeded ==
true);
131 stdair::DCPList_T::const_iterator itNextDCP = itDCP; ++itNextDCP;
132 for (; itNextDCP != iDCPList.end(); ++itDCP, ++itNextDCP) {
133 const stdair::DCP_T& lCurrentDCP = *itDCP;
134 const stdair::DCP_T& lNextDCP = *itNextDCP;
137 STDAIR_LOG_DEBUG (
"Unconstrain demand for "
138 << ioSegmentCabin.describeKey()
139 <<
" and the DCP's " << lCurrentDCP <<
", "
143 lQEquivalentDemandVector,
144 lCurrentDCP-1, lNextDCP,
146 STDAIR_LOG_DEBUG (
"Detrucation successful");
150 FRAT5Curve_T::const_iterator itFRAT5 =
153 const double lFRAT5Coef = itFRAT5->second;
154 const double lSellUpCoef = -log(0.5) / (lFRAT5Coef - 1);
157 lQEquivalentDemandVector, lSellUpCoef);
167 const double& iSellUpFactor) {
168 double lPriceOriMean;
double lPriceOriStdDev;
178 const stdair::BookingClassList_T& lBCList =
179 stdair::BomManager::getList<stdair::BookingClass> (ioSegmentCabin);
180 stdair::BookingClassList_T::const_reverse_iterator itCurrentClass =
182 assert (itCurrentClass != lBCList.rend());
183 stdair::BookingClassList_T::const_reverse_iterator itNextClass =
188 if (itNextClass == lBCList.rend()) {
189 stdair::BookingClass* lLowestBC_ptr = *itCurrentClass;
190 lLowestBC_ptr->setMean (lPriceOriMean);
191 lLowestBC_ptr->setStdDev (lPriceOriStdDev);
195 for (; itNextClass != lBCList.rend(); ++itCurrentClass, ++itNextClass) {
196 stdair::BookingClass* lCurrentBC_ptr = *itCurrentClass;
197 assert (lCurrentBC_ptr != NULL);
198 const stdair::Yield_T& lCurrentYield = lCurrentBC_ptr->getYield();
199 stdair::BookingClass* lNextBC_ptr = *itNextClass;
200 assert (lNextBC_ptr != NULL);
201 const stdair::Yield_T& lNextYield = lNextBC_ptr->getYield();
205 const double lSellUp =
206 exp ((1.0 - lNextYield/lCurrentYield) * iSellUpFactor);
207 const double lPriceOriDemMeanFrac = lPriceOriMean * (1.0 - lSellUp);
208 const double lPriceOriDemStdDevFrac = lPriceOriStdDev * (1.0 - lSellUp);
212 BookingClassUnconstrainedDemandVectorMap_T::const_iterator itBCUD =
213 iClassUncDemMap.find (lCurrentBC_ptr);
214 assert (itBCUD != iClassUncDemMap.end());
216 double lMean;
double lStdDev;
220 lMean += lPriceOriDemMeanFrac;
221 lStdDev = sqrt (lStdDev * lStdDev +
222 lPriceOriDemStdDevFrac * lPriceOriDemStdDevFrac);
223 lCurrentBC_ptr->setMean (lMean);
224 lCurrentBC_ptr->setStdDev (lStdDev);
232 lPriceOriMean *= lSellUp;
233 lPriceOriStdDev *= lSellUp;
238 stdair::BookingClass* lCurrentBC_ptr = *itCurrentClass;
239 assert (lCurrentBC_ptr != NULL);
240 BookingClassUnconstrainedDemandVectorMap_T::const_iterator itBCUD =
241 iClassUncDemMap.find (lCurrentBC_ptr);
242 assert (itBCUD != iClassUncDemMap.end());
244 double lMean;
double lStdDev;
248 lMean += lPriceOriMean;
249 lStdDev = sqrt (lStdDev * lStdDev + lPriceOriStdDev * lPriceOriStdDev);
250 lCurrentBC_ptr->setMean (lMean);
251 lCurrentBC_ptr->setStdDev (lStdDev);
262 setRemainingDemandForecastToZero (
const stdair::SegmentCabin& iSegmentCabin) {
264 const stdair::BookingClassList_T& lBCList =
265 stdair::BomManager::getList<stdair::BookingClass> (iSegmentCabin);
266 for (stdair::BookingClassList_T::const_iterator itBC = lBCList.begin();
267 itBC != lBCList.end(); ++itBC) {
268 stdair::BookingClass* lBC_ptr = *itBC;
269 assert (lBC_ptr != NULL);
270 lBC_ptr->setMean (0.0);
277 const stdair::DateTime_T& iEventTime) {
279 const stdair::Date_T& lEventDate = iEventTime.date();
282 bool isSucceeded =
true;
283 const stdair::SegmentDateList_T& lSDList =
284 stdair::BomManager::getList<stdair::SegmentDate> (ioFlightDate);
285 for (stdair::SegmentDateList_T::const_iterator itSD = lSDList.begin();
286 itSD != lSDList.end(); ++itSD) {
287 stdair::SegmentDate* lSD_ptr = *itSD;
288 assert (lSD_ptr != NULL);
290 const stdair::Date_T& lBoardingDate = lSD_ptr->getBoardingDate();
291 const stdair::DateOffset_T lSegmentDateOffset =
292 lBoardingDate - lEventDate;
293 const stdair::DTD_T lSegmentDTD = lSegmentDateOffset.days();
296 const stdair::SegmentCabinList_T& lSCList =
297 stdair::BomManager::getList<stdair::SegmentCabin> (*lSD_ptr);
298 for (stdair::SegmentCabinList_T::const_iterator itSC = lSCList.begin();
299 itSC != lSCList.end(); ++itSC) {
300 stdair::SegmentCabin* lSC_ptr = *itSC;
301 assert (lSC_ptr != NULL);
306 if (isForecasted ==
false) {
317 const stdair::Date_T& iEventDate,
318 const stdair::DTD_T& iSegmentDTD) {
320 const stdair::GuillotineBlock& lGuillotineBlock =
321 ioSegmentCabin.getGuillotineBlock();
322 stdair::NbOfSegments_T lNbOfAnteriorSimilarSegments =
327 stdair::NbOfSegments_T lNbOfDepartedSegments =
330 if (lNbOfDepartedSegments > 52) {
331 lNbOfAnteriorSimilarSegments =
332 lNbOfAnteriorSimilarSegments - lNbOfDepartedSegments + 52;
336 STDAIR_LOG_DEBUG (
"Nb of anterior similar segments: "
337 << lNbOfAnteriorSimilarSegments);
341 stdair::DCPList_T::const_reverse_iterator itLastDCP =
344 const stdair::DCP_T& lLastDCP = *itLastDCP;
345 if (lNbOfAnteriorSimilarSegments < 1.0 || iSegmentDTD <= lLastDCP) {
346 setRemainingDemandForecastToZero (ioSegmentCabin);
353 const stdair::DCP_T& lFirstDCP = *itDCP;
356 stdair::NbOfSegments_T lNbOfUsableSegments =
361 unsigned short lSize = lNbOfUsableSegments;
362 if (lNbOfDepartedSegments > 52) {
363 lSize = lNbOfUsableSegments - lNbOfDepartedSegments + 52;
366 STDAIR_LOG_DEBUG (
"Nb of usable similar segments: "
367 << lNbOfUsableSegments);
370 stdair::NbOfBookings_T lCurrentSegmentQEquivalentDemand = 0.0;
373 const stdair::BookingClassList_T& lBCList =
374 stdair::BomManager::getList<stdair::BookingClass> (ioSegmentCabin);
375 for (stdair::BookingClassList_T::const_iterator itBC = lBCList.begin();
376 itBC != lBCList.end(); ++itBC) {
377 stdair::BookingClass* lBC_ptr = *itBC;
378 assert (lBC_ptr != NULL);
381 bool insertionSucceeded = lBkgClassUncDemVectorMap.
383 value_type (lBC_ptr, lUncDemandVector)).second;
384 assert (insertionSucceeded ==
true);
386 lCurrentSegmentBkgClassDemMap.
388 value_type (lBC_ptr, 0.0)).second;
389 assert (insertionSucceeded ==
true);
393 lBkgClassUncDemVectorMap,
394 lQEquivalentDemandVector,
395 lFirstDCP, lNbOfUsableSegments,
399 stdair::DCPList_T::const_iterator itNextDCP = itDCP; ++itNextDCP;
401 const stdair::DCP_T& lCurrentDCP = *itDCP;
402 const stdair::DCP_T& lNextDCP = *itNextDCP;
403 if (lCurrentDCP <= iSegmentDTD) {
408 lBkgClassUncDemVectorMap,
409 lQEquivalentDemandVector,
410 lCurrentDCP-1, lNextDCP,
412 lNbOfDepartedSegments);
413 ++itNextDCP; ++itDCP;
418 lCurrentSegmentQEquivalentDemand =
419 lQEquivalentDemandVector.at (lNbOfAnteriorSimilarSegments);
420 BookingClassUnconstrainedDemandMap_T::iterator itBCUD =
421 lCurrentSegmentBkgClassDemMap.begin();
422 for (BookingClassUnconstrainedDemandVectorMap_T::iterator itBCUDV =
423 lBkgClassUncDemVectorMap.begin();
424 itBCUDV != lBkgClassUncDemVectorMap.end(); ++itBCUDV, ++itBCUD) {
425 assert (itBCUD != lCurrentSegmentBkgClassDemMap.end());
426 assert (itBCUD->first == itBCUDV->first);
427 stdair::NbOfRequests_T& lUncDem = itBCUD->second;
429 lUncDem = lUncDemVector.at (lNbOfAnteriorSimilarSegments);
433 const stdair::DCP_T& lCurrentDTD = *itDCP;
435 const stdair::DCP_T& lCurrentDCP = *itDCP;
436 const stdair::DCP_T& lNextDCP = *itNextDCP;
438 lBkgClassUncDemVectorMap,
439 lQEquivalentDemandVector,
440 lCurrentDCP-1, lNextDCP, iEventDate,
441 lNbOfAnteriorSimilarSegments,
442 lNbOfDepartedSegments);
446 lCurrentSegmentQEquivalentDemand =
447 lQEquivalentDemandVector.at (lNbOfAnteriorSimilarSegments)
448 - lCurrentSegmentQEquivalentDemand;
449 itBCUD = lCurrentSegmentBkgClassDemMap.begin();
450 for (BookingClassUnconstrainedDemandVectorMap_T::iterator itBCUDV =
451 lBkgClassUncDemVectorMap.begin();
452 itBCUDV != lBkgClassUncDemVectorMap.end(); ++itBCUDV, ++itBCUD) {
453 assert (itBCUD != lCurrentSegmentBkgClassDemMap.end());
454 assert (itBCUD->first == itBCUDV->first);
455 stdair::NbOfRequests_T& lUncDem = itBCUD->second;
457 lUncDem = lUncDemVector.at (lNbOfAnteriorSimilarSegments) - lUncDem;
461 FRAT5Curve_T::const_iterator itFRAT5 =
464 const double lFRAT5Coef = itFRAT5->second;
465 const double lSellUpCoef = -log(0.5) / (lFRAT5Coef - 1);
468 lCurrentSegmentBkgClassDemMap,
469 lCurrentSegmentQEquivalentDemand,
477 (
const stdair::SegmentCabin& iSegmentCabin,
480 const stdair::DCP_T& iDCPBegin,
const stdair::DCP_T& iDCPEnd,
481 const stdair::Date_T& iCurrentDate,
482 const stdair::NbOfSegments_T& iNbOfAnteriorSimilarSegments,
483 const stdair::NbOfSegments_T& iNbOfDepartedSegments) {
486 const stdair::GuillotineBlock& lGuillotineBlock =
487 iSegmentCabin.getGuillotineBlock();
495 STDAIR_LOG_DEBUG (
"Nb of usable similar segments: "
496 << lNbOfUsableSegments);
498 if (lNbOfUsableSegments > 0) {
501 for (BookingClassUnconstrainedDemandVectorMap_T::iterator itBCUDV =
502 ioBkgClassUncDemMap.begin(); itBCUDV != ioBkgClassUncDemMap.end();
504 stdair::BookingClass* lBC_ptr = itBCUDV->first;
505 assert (lBC_ptr != NULL);
506 const stdair::MapKey_T& lBCKey = lBC_ptr->describeKey();
507 const stdair::BlockIndex_T& lBlockIdx =
508 lGuillotineBlock.getBlockIndex (lBCKey);
511 STDAIR_LOG_DEBUG (
"Unconstrain product-oriented bookings for "<<lBCKey);
514 lNbOfUsableSegments, lBlockIdx,
515 iNbOfAnteriorSimilarSegments,
516 iNbOfDepartedSegments);
521 std::ostringstream lSCMapKey;
522 lSCMapKey << stdair::DEFAULT_SEGMENT_CABIN_VALUE_TYPE
523 << iSegmentCabin.describeKey();
524 const stdair::BlockIndex_T& lCabinIdx =
525 lGuillotineBlock.getBlockIndex (lSCMapKey.str());
527 STDAIR_LOG_DEBUG (
"Unconstrain price-oriented bookings");
529 ioQEquivalentDemandVector,
531 lNbOfUsableSegments, lCabinIdx,
532 iNbOfAnteriorSimilarSegments,
533 iNbOfDepartedSegments,
534 iSegmentCabin, iCurrentDate);
540 (
const stdair::GuillotineBlock& iGuillotineBlock,
542 const stdair::DCP_T& iDCPBegin,
const stdair::DCP_T& iDCPEnd,
543 const stdair::NbOfSegments_T& iNbOfUsableSegments,
544 const stdair::BlockIndex_T& iBlockIdx,
545 const stdair::NbOfSegments_T& iNbOfAnteriorSimilarSegments,
546 const stdair::NbOfSegments_T& iNbOfDepartedSegments) {
548 stdair::NbOfSegments_T lSegBegin = 0;
549 if (iNbOfDepartedSegments > 52) {
550 lSegBegin = iNbOfDepartedSegments - 52;
553 stdair::ConstSegmentCabinDTDRangeSnapshotView_T lBookingView =
554 iGuillotineBlock.getConstSegmentCabinDTDRangeProductAndPriceOrientedBookingSnapshotView (lSegBegin, iNbOfUsableSegments -1, iDCPEnd, iDCPBegin);
555 stdair::ConstSegmentCabinDTDRangeSnapshotView_T lAvlView =
556 iGuillotineBlock.getConstSegmentCabinDTDRangeAvailabilitySnapshotView (lSegBegin, iNbOfUsableSegments -1, iDCPEnd, iDCPBegin);
559 const stdair::ValueTypeIndexMap_T& lVTIdxMap =
560 iGuillotineBlock.getValueTypeIndexMap();
561 const unsigned int lNbOfValueTypes = lVTIdxMap.size();
562 HistoricalBookingHolder lHBHolder;
563 std::vector<short> lDataIndexList;
564 for (
short i = 0; i < iNbOfUsableSegments-lSegBegin; ++i) {
565 stdair::Flag_T lCensorshipFlag =
false;
566 stdair::NbOfBookings_T lNbOfHistoricalBkgs = 0.0;
567 const short lNbOfDTDs = iDCPBegin - iDCPEnd + 1;
570 for (
short j = 0; j < lNbOfDTDs; ++j) {
574 if (lCensorshipFlag ==
false) {
575 if (lAvlView[i*lNbOfValueTypes + iBlockIdx][j] < 1.0) {
576 lCensorshipFlag =
true;
582 lNbOfHistoricalBkgs += lBookingView[i*lNbOfValueTypes + iBlockIdx][j];
587 stdair::NbOfRequests_T& lUncDemand = ioUncDemVector.at (i);
588 if (lUncDemand < 1.0) {
589 lUncDemand += lNbOfHistoricalBkgs;
591 double lBkgDemandFactor = lNbOfHistoricalBkgs / lUncDemand;
592 HistoricalBooking lHistoricalBkg (lBkgDemandFactor, lCensorshipFlag);
593 lHBHolder.addHistoricalBooking (lHistoricalBkg);
594 lDataIndexList.push_back (i);
598 STDAIR_LOG_DEBUG (
"Historical bkgs: " << lNbOfHistoricalBkgs
599 <<
", censored: " << lCensorshipFlag);
603 STDAIR_LOG_DEBUG (
"Unconstrain by multiplicative pick-up using EM");
610 for (std::vector<short>::iterator itIdx = lDataIndexList.begin();
611 itIdx != lDataIndexList.end(); ++itIdx, ++i) {
613 stdair::NbOfRequests_T& lPastDemand = ioUncDemVector.at (lIdx);
614 const stdair::NbOfRequests_T& lUncDemandFactorOfThisPeriod =
615 lHBHolder.getUnconstrainedDemand (i);
616 lPastDemand *= (1+lUncDemandFactorOfThisPeriod);
620 if (lHBHolder.getNbOfFlights() > 0) {
621 const stdair::NbOfRequests_T& lUncDemandFactorMean =
622 lHBHolder.getDemandMean();
623 stdair::NbOfRequests_T& lPastDemand =
624 ioUncDemVector.at (iNbOfAnteriorSimilarSegments);
625 lPastDemand *= (1+lUncDemandFactorMean);
631 (
const stdair::GuillotineBlock& iGuillotineBlock,
633 const stdair::DCP_T& iDCPBegin,
const stdair::DCP_T& iDCPEnd,
634 const stdair::NbOfSegments_T& iNbOfUsableSegments,
635 const stdair::BlockIndex_T& iBlockIdx,
636 const stdair::NbOfSegments_T& iNbOfAnteriorSimilarSegments,
637 const stdair::NbOfSegments_T& iNbOfDepartedSegments,
638 const stdair::SegmentCabin& iSegmentCabin,
639 const stdair::Date_T& iCurrentDate) {
641 stdair::NbOfSegments_T lSegBegin = 0;
642 if (iNbOfDepartedSegments > 52) {
643 lSegBegin = iNbOfDepartedSegments - 52;
646 stdair::ConstSegmentCabinDTDRangeSnapshotView_T lBookingView =
647 iGuillotineBlock.getConstSegmentCabinDTDRangeProductAndPriceOrientedBookingSnapshotView (lSegBegin, iNbOfUsableSegments -1, iDCPEnd, iDCPBegin);
648 stdair::ConstSegmentCabinDTDRangeSnapshotView_T lAvlView =
649 iGuillotineBlock.getConstSegmentCabinDTDRangeAvailabilitySnapshotView (lSegBegin, iNbOfUsableSegments -1, iDCPEnd, iDCPBegin);
652 const stdair::ValueTypeIndexMap_T& lVTIdxMap =
653 iGuillotineBlock.getValueTypeIndexMap();
654 const unsigned int lNbOfValueTypes = lVTIdxMap.size();
655 HistoricalBookingHolder lHBHolder;
656 std::vector<short> lDataIndexList;
657 for (
short i = 0; i < iNbOfUsableSegments-lSegBegin; ++i) {
658 stdair::Flag_T lCensorshipFlag =
false;
659 stdair::NbOfBookings_T lNbOfHistoricalBkgs = 0.0;
660 const short lNbOfDTDs = iDCPBegin - iDCPEnd + 1;
663 for (
short j = 0; j < lNbOfDTDs; ++j) {
667 if (lCensorshipFlag ==
false) {
668 if (lAvlView[i*lNbOfValueTypes + iBlockIdx][j] < 1.0) {
669 lCensorshipFlag =
true;
675 lNbOfHistoricalBkgs += lBookingView[i*lNbOfValueTypes + iBlockIdx][j];
680 stdair::NbOfRequests_T& lUncDemand = ioUncDemVector.at (i);
681 if (lUncDemand < 1.0) {
682 lUncDemand += lNbOfHistoricalBkgs;
684 double lBkgDemandFactor = lNbOfHistoricalBkgs / lUncDemand;
685 HistoricalBooking lHistoricalBkg (lBkgDemandFactor, lCensorshipFlag);
686 lHBHolder.addHistoricalBooking (lHistoricalBkg);
687 lDataIndexList.push_back (i);
691 STDAIR_LOG_DEBUG (
"Historical bkgs: " << lNbOfHistoricalBkgs
692 <<
", censored: " << lCensorshipFlag);
696 STDAIR_LOG_DEBUG (
"Unconstrain by multiplicative pick-up using EM");
703 const stdair::SegmentDate& lSegmentDate = stdair::BomManager::
704 getParent<stdair::SegmentDate, stdair::SegmentCabin> (iSegmentCabin);
705 const stdair::FlightDate& lFlightDate = stdair::BomManager::
706 getParent<stdair::FlightDate, stdair::SegmentDate> (lSegmentDate);
707 const stdair::Date_T& lDepDate = lFlightDate.getDepartureDate();
708 const boost::gregorian::date_duration lDD = lDepDate - iCurrentDate;
709 const long lDTD = lDD.days();
710 stdair::Date_T lRefDate (2012, boost::gregorian::Jan, 01);
712 for (std::vector<short>::iterator itIdx = lDataIndexList.begin();
713 itIdx != lDataIndexList.end(); ++itIdx, ++i) {
715 stdair::NbOfRequests_T& lPastDemand = ioUncDemVector.at (lIdx);
716 const stdair::NbOfRequests_T& lUncDemandFactorOfThisPeriod =
717 lHBHolder.getUnconstrainedDemand (i);
718 const double lUncDemThisPeriod =
719 lPastDemand * lUncDemandFactorOfThisPeriod;
720 const double lQEBkgThisPeriod =
721 lPastDemand * lHBHolder.getHistoricalBooking (i);
722 lPastDemand *= (1+lUncDemandFactorOfThisPeriod);
723 if (lDepDate > lRefDate) {
724 const stdair::DateOffset_T lDateOffset (7 *(52 - i) + 420);
725 const stdair::Date_T lHDate = lDepDate - lDateOffset;
726 STDAIR_LOG_NOTIFICATION (boost::gregorian::to_iso_string(lDepDate)
727 <<
";" << lDTD <<
";" << iDCPBegin <<
";"
729 << boost::gregorian::to_iso_string (lHDate)
730 <<
";" << lUncDemThisPeriod);
731 STDAIR_LOG_NOTIFICATION (boost::gregorian::to_iso_string(lDepDate)
732 <<
";" << lDTD <<
";" << iDCPBegin <<
";"
734 << boost::gregorian::to_iso_string (lHDate)
735 <<
";" << lQEBkgThisPeriod);
740 if (lHBHolder.getNbOfFlights() > 0) {
741 const stdair::NbOfRequests_T& lUncDemandFactorMean =
742 lHBHolder.getDemandMean();
743 stdair::NbOfRequests_T& lPastDemand =
744 ioUncDemVector.at (iNbOfAnteriorSimilarSegments);
745 lPastDemand *= (1+lUncDemandFactorMean);
753 const stdair::NbOfRequests_T& iUncDem,
754 const double& iSellUpFactor) {
755 double lPriceOriMean = iUncDem;
756 double lPriceOriStdDev = sqrt (iUncDem);
759 STDAIR_LOG_DEBUG (
"Price-oriented demand: mean = " << lPriceOriMean
760 <<
", stddev = " << lPriceOriStdDev);
765 const stdair::BookingClassList_T& lBCList =
766 stdair::BomManager::getList<stdair::BookingClass> (ioSegmentCabin);
767 stdair::BookingClassList_T::const_reverse_iterator itCurrentClass =
769 assert (itCurrentClass != lBCList.rend());
770 stdair::BookingClassList_T::const_reverse_iterator itNextClass =
775 if (itNextClass == lBCList.rend()) {
776 stdair::BookingClass* lLowestBC_ptr = *itCurrentClass;
777 lLowestBC_ptr->setMean (lPriceOriMean);
778 lLowestBC_ptr->setStdDev (lPriceOriStdDev);
779 if (lPriceOriMean > 0) {
785 bool isSucceeded =
false;
788 for (; itNextClass != lBCList.rend(); ++itCurrentClass, ++itNextClass) {
789 stdair::BookingClass* lCurrentBC_ptr = *itCurrentClass;
790 assert (lCurrentBC_ptr != NULL);
791 const stdair::Yield_T& lCurrentYield = lCurrentBC_ptr->getYield();
792 stdair::BookingClass* lNextBC_ptr = *itNextClass;
793 assert (lNextBC_ptr != NULL);
794 const stdair::Yield_T& lNextYield = lNextBC_ptr->getYield();
798 const double lSellUp =
799 exp ((1.0 - lNextYield/lCurrentYield) * iSellUpFactor);
800 const double lPriceOriDemMeanFrac = lPriceOriMean * (1.0 - lSellUp);
801 const double lPriceOriDemStdDevFrac = lPriceOriStdDev * (1.0 - lSellUp);
805 BookingClassUnconstrainedDemandMap_T::const_iterator itBCUD =
806 iClassUncDemMap.find (lCurrentBC_ptr);
807 assert (itBCUD != iClassUncDemMap.end());
808 double lMean = itBCUD->second;
809 double lStdDev = sqrt (lMean);
812 lMean += lPriceOriDemMeanFrac;
813 lStdDev = sqrt (lStdDev * lStdDev +
814 lPriceOriDemStdDevFrac * lPriceOriDemStdDevFrac);
815 lCurrentBC_ptr->setMean (lMean);
816 lCurrentBC_ptr->setStdDev (lStdDev);
823 STDAIR_LOG_DEBUG (
"Class " << lCurrentBC_ptr->describeKey()
824 <<
", mean = " << lMean
825 <<
", stddev = " << lStdDev);
828 lPriceOriMean *= lSellUp;
829 lPriceOriStdDev *= lSellUp;
834 stdair::BookingClass* lCurrentBC_ptr = *itCurrentClass;
835 assert (lCurrentBC_ptr != NULL);
836 BookingClassUnconstrainedDemandMap_T::const_iterator itBCUD =
837 iClassUncDemMap.find (lCurrentBC_ptr);
838 assert (itBCUD != iClassUncDemMap.end());
839 double lMean = itBCUD->second;
840 double lStdDev = sqrt (lMean);
843 lMean += lPriceOriMean;
844 lStdDev = sqrt (lStdDev * lStdDev + lPriceOriStdDev * lPriceOriStdDev);
845 lCurrentBC_ptr->setMean (lMean);
846 lCurrentBC_ptr->setStdDev (lStdDev);
853 STDAIR_LOG_DEBUG (
"Class " << lCurrentBC_ptr->describeKey()
854 <<
", mean = " << lMean
855 <<
", stddev = " << lStdDev);