DemandStream.hpp

Go to the documentation of this file.

#ifndef __TRADEMGEN_BOM_DEMANDSTREAM_HPP
#define __TRADEMGEN_BOM_DEMANDSTREAM_HPP

// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// StdAir
#include <stdair/bom/BomAbstract.hpp>
#include <stdair/bom/BookingRequestTypes.hpp>
#include <stdair/basic/RandomGeneration.hpp>
#include <stdair/basic/DemandGenerationMethod.hpp>
// TraDemGen
#include <trademgen/basic/DemandCharacteristics.hpp>
#include <trademgen/basic/DemandDistribution.hpp>
#include <trademgen/basic/RandomGenerationContext.hpp>
#include <trademgen/bom/DemandStreamKey.hpp>
#include <trademgen/bom/DemandStreamTypes.hpp>

namespace stdair {
  class FacBomManager;
  template <typename BOM> class FacBom;
}

namespace TRADEMGEN {
  
  class DemandStream : public stdair::BomAbstract {
    template <typename BOM> friend class stdair::FacBom;
    friend class stdair::FacBomManager;

  public:
    // ////////// Type definitions ////////////
    typedef DemandStreamKey Key_T;


  public:
    // ///////////// Getters ///////////
    const Key_T& getKey() const {
      return _key;
    }
    
    BomAbstract* const getParent() const {
      return _parent;
    }
    
    const stdair::AirportCode_T& getOrigin() const {
      return _key.getOrigin();
    }

    const stdair::AirportCode_T& getDestination() const {
      return _key.getDestination();
    }

    const stdair::Date_T& getPreferredDepartureDate() const {
      return _key.getPreferredDepartureDate();
    }
    
    const stdair::CabinCode_T& getPreferredCabin() const {
      return _key.getPreferredCabin();
    }
    
    const stdair::HolderMap_T& getHolderMap() const {
      return _holderMap;
    }
    
    const DemandCharacteristics& getDemandCharacteristics() const {
      return _demandCharacteristics;
    }

    const DemandDistribution& getDemandDistribution() const {
      return _demandDistribution;
    }

    const stdair::NbOfRequests_T& getTotalNumberOfRequestsToBeGenerated() const{
      return _totalNumberOfRequestsToBeGenerated;
    }

    const stdair::NbOfRequests_T& getMeanNumberOfRequests() const {
      return _demandDistribution._meanNumberOfRequests;
    }
    
    const stdair::StdDevValue_T& getStdDevNumberOfRequests() const {
      return _demandDistribution._stdDevNumberOfRequests;
    }
    
    const stdair::Count_T& getNumberOfRequestsGeneratedSoFar() const {
      return _randomGenerationContext.getNumberOfRequestsGeneratedSoFar();
    }

    const stdair::Disutility_T& getChangeFeeDisutility() const {
      return _demandCharacteristics._changeFeeDisutility;
    }

    const stdair::Disutility_T& getNonRefundableDisutility() const {
      return _demandCharacteristics._nonRefundableDisutility;
    }

    const POSProbabilityMass_T& getPOSProbabilityMass() const {
      return _posProMass;
    }


  public:
    // //////////////// Setters //////////////////    
    void setNumberOfRequestsGeneratedSoFar (const stdair:: Count_T& iCount) {
      _randomGenerationContext.setNumberOfRequestsGeneratedSoFar (iCount);
    }

    void setDemandDistribution (const DemandDistribution& iDemandDistribution) {
      _demandDistribution = iDemandDistribution;
    }

    void
    setDemandCharacteristics (const ArrivalPatternCumulativeDistribution_T& iArrivalPattern,
                              const POSProbabilityMassFunction_T& iPOSProbMass,
                              const ChannelProbabilityMassFunction_T& iChannelProbMass,
                              const TripTypeProbabilityMassFunction_T& iTripTypeProbMass,
                              const StayDurationProbabilityMassFunction_T& iStayDurationProbMass,
                              const FrequentFlyerProbabilityMassFunction_T& iFrequentFlyerProbMass,
                              const stdair::ChangeFeesRatio_T& iChangeFeeProb,
                              const stdair::Disutility_T& iChangeFeeDisutility,
                              const stdair::NonRefundableRatio_T& iNonRefundableProb,
                              const stdair::Disutility_T& iNonRefundableDisutility,
                              const PreferredDepartureTimeContinuousDistribution_T& iPreferredDepartureTimeContinuousDistribution,
                              const stdair::WTP_T& iMinWTP,
                              const ValueOfTimeContinuousDistribution_T& iValueOfTimeContinuousDistribution) {
      _demandCharacteristics =
        DemandCharacteristics (iArrivalPattern, iPOSProbMass,
                               iChannelProbMass, iTripTypeProbMass,
                               iStayDurationProbMass, iFrequentFlyerProbMass,
                               iChangeFeeProb, iChangeFeeDisutility,
                               iNonRefundableProb, iNonRefundableDisutility,
                               iPreferredDepartureTimeContinuousDistribution,
                               iMinWTP, iValueOfTimeContinuousDistribution);
    }

    void setTotalNumberOfRequestsToBeGenerated (const stdair::NbOfRequests_T& iNbOfRequests) {
      _totalNumberOfRequestsToBeGenerated = iNbOfRequests;
    }

    void setRequestDateTimeRandomGeneratorSeed (const stdair::RandomSeed_T& iSeed) {
      _requestDateTimeRandomGenerator.init (iSeed);
    }

    void setDemandCharacteristicsRandomGeneratorSeed (const stdair::RandomSeed_T& iSeed) {
      _demandCharacteristicsRandomGenerator.init (iSeed);
    }

    void setPOSProbabilityMass (const POSProbabilityMass_T& iProbMass) {
      _posProMass = iProbMass;
    }

    void setAll (const ArrivalPatternCumulativeDistribution_T&,
                 const POSProbabilityMassFunction_T&,
                 const ChannelProbabilityMassFunction_T&,
                 const TripTypeProbabilityMassFunction_T&,
                 const StayDurationProbabilityMassFunction_T&,
                 const FrequentFlyerProbabilityMassFunction_T&,
                 const stdair::ChangeFeesRatio_T&,
                 const stdair::Disutility_T&,
                 const stdair::NonRefundableRatio_T&,
                 const stdair::Disutility_T&,
                 const PreferredDepartureTimeContinuousDistribution_T&,
                 const stdair::WTP_T&,
                 const ValueOfTimeContinuousDistribution_T&,
                 const DemandDistribution&,
                 stdair::BaseGenerator_T& ioSharedGenerator,
                 const stdair::RandomSeed_T& iRequestDateTimeSeed,
                 const stdair::RandomSeed_T& iDemandCharacteristicsSeed,
                 const POSProbabilityMass_T&);

    void setBoolFirstDateTimeRequest (const bool& iFirstDateTimeRequest) {
      _firstDateTimeRequest = iFirstDateTimeRequest;
    }
    

  public:
    // /////////////////// Business Methods ///////////////////
    void incrementGeneratedRequestsCounter() {
      _randomGenerationContext.incrementGeneratedRequestsCounter();
    }
    
    const bool stillHavingRequestsToBeGenerated (const stdair::DemandGenerationMethod& iDemandGenerationMethod) const;

    const stdair::DateTime_T generateTimeOfRequestPoissonProcess();

    const stdair::DateTime_T generateTimeOfRequestStatisticsOrder();

    const stdair::AirportCode_T generatePOS();

    const stdair::ChannelLabel_T generateChannel();

    const stdair::TripType_T generateTripType();

    const stdair::DayDuration_T generateStayDuration();

    const stdair::FrequentFlyer_T generateFrequentFlyer();

    const stdair::ChangeFees_T generateChangeFees();

    const stdair::NonRefundable_T generateNonRefundable();

    const stdair::Duration_T generatePreferredDepartureTime();
    
    const stdair::WTP_T generateWTP (stdair::RandomGeneration&,
                                     const stdair::Date_T&,
                                     const stdair::DateTime_T&,
                                     const stdair::DayDuration_T&);

    const stdair::PriceValue_T generateValueOfTime();
    
    stdair::BookingRequestPtr_T
    generateNextRequest (stdair::RandomGeneration&,
                         const stdair::DemandGenerationMethod&);

    void reset (stdair::BaseGenerator_T& ioSharedGenerator);
       

  public:
    // ////////////////// Display support methods //////////////
    void toStream (std::ostream& ioOut) const {
      ioOut << toString();
    }

    void fromStream (std::istream& ioIn) {
    }

    std::string toString() const;
    
    const std::string describeKey() const {
      return _key.toString();
    }

    std::string display() const;
    const stdair::Duration_T convertFloatIntoDuration (const stdair::FloatDuration_T);
    
  protected:
    // ////////// Constructors and destructors /////////
    DemandStream (const Key_T&);
    virtual ~DemandStream();

  private:
    DemandStream();
    DemandStream (const DemandStream&);
    void init (stdair::BaseGenerator_T& ioSharedGenerator);

    
  protected:
    // ////////// Attributes //////////
    Key_T _key;
    
    BomAbstract* _parent;
    
    stdair::HolderMap_T _holderMap;
    
    DemandCharacteristics _demandCharacteristics;

    DemandDistribution _demandDistribution;
    
    stdair::NbOfRequests_T _totalNumberOfRequestsToBeGenerated;

    RandomGenerationContext _randomGenerationContext;
    
    stdair::RandomGeneration _requestDateTimeRandomGenerator;
    
    stdair::RandomGeneration _demandCharacteristicsRandomGenerator;

    POSProbabilityMass_T _posProMass;

  private:
    bool _stillHavingRequestsToBeGenerated;
    bool _firstDateTimeRequest;
    stdair::FloatDuration_T _dateTimeLastRequest;
  };

}
#endif // __TRADEMGEN_BOM_DEMANDSTREAM_HPP