OperationItemSupplier::OperationItemSupplier(
ItemSupplier* i, Buffer *b
) : supitem(i)
{
if (!i || !b || !i->getSupplier())
throw LogicException(
"An OperationItemSupplier always needs to point to "
"a itemsupplier and a buffer"
);
stringstream o;
o << "Purchase " << b->getName() << " from " << i->getSupplier()->getName();
setName(o.str());
setDuration(i->getLeadTime());
setSizeMultiple(i->getSizeMultiple());
setSizeMinimum(i->getSizeMinimum());
setLocation(b->getLocation());
setSource(i->getSource());
setCost(i->getCost());
setFence(i->getFence());
setHidden(true);
new FlowEnd(this, b, 1);
initType(metadata);
// Optionally, create a load
if (i->getResource())
new LoadDefault(this, i->getResource(), i->getResourceQuantity());
// Insert in the list of ItemSupplier operations.
// The list is not sorted (for performance reasons).
nextOperation = i->firstOperation;
i->firstOperation = this;
}
OperationItemDistribution::OperationItemDistribution(
ItemDistribution* i, Buffer *src, Buffer* dest
) : itemdist(i)
{
if (!i || !src || !dest)
throw LogicException(
"An OperationItemDistribution always needs to point to "
"a ItemDistribution, a source buffer and a destination buffer"
);
stringstream o;
o << "Ship " << dest->getItem()->getName() << " from " << src->getName() << " to " << dest->getName();
setName(o.str());
setDuration(i->getLeadTime());
setSizeMultiple(i->getSizeMultiple());
setSizeMinimum(i->getSizeMinimum());
setLocation(dest->getLocation());
setSource(i->getSource());
setCost(i->getCost());
setFence(i->getFence());
setHidden(true);
new FlowEnd(this, dest, 1);
new FlowStart(this, src, -1);
initType(metadata);
// Optionally, create a load
if (i->getResource())
new LoadDefault(this, i->getResource(), i->getResourceQuantity());
// Insert in the list of ItemDistribution operations.
// The list is not sorted (for performance reasons).
nextOperation = i->firstOperation;
i->firstOperation = this;
}
ItemDistribution::ItemDistribution()
{
initType(metadata);
// Trigger level and cluster recomputation
HasLevel::triggerLazyRecomputation();
}
DECLARE_EXPORT LoadPlan::LoadPlan(OperationPlan *o, const Load *r, LoadPlan *lp)
{
ld = const_cast<Load*>(r);
oper = o;
start_or_end = END;
// Update the resource field
res = lp->getResource();
// Add to the operationplan
nextLoadPlan = NULL;
if (o->firstloadplan)
{
// Append to the end
LoadPlan *c = o->firstloadplan;
while (c->nextLoadPlan) c = c->nextLoadPlan;
c->nextLoadPlan = this;
}
else
// First in the list
o->firstloadplan = this;
// Insert in the resource timeline
getResource()->loadplans.insert(
this,
ld->getLoadplanQuantity(this),
ld->getLoadplanDate(this)
);
// Initialize the Python type
initType(metadata);
}
void TDBoss::initAttributeWithIndex(int type,int id)
{
m_nType = type;
m_birthPosition = Point(GLB_SIZE.width-120,100);
m_nId = id;
m_nHP = 300;
m_fHpBackUp = static_cast<float>(m_nHP);
m_nAttackRate = 1;
m_nDPS = 200;
//初始化BossHp;
Sprite* bg = Sprite::create(RESOURCE("td/ui_hpboss01.png"));
bg->setPosition(Vec2(0,100.f));
this->addChild(bg,Z_First);
m_BossHpProgress = ProgressTimer::create(Sprite::create(RESOURCE("td/ui_hpboss02.png")));//创建一个进程条;
m_BossHpProgress->setAnchorPoint(Vec2::ZERO);
m_BossHpProgress->setBarChangeRate(Point(1,0));//设置进程条的变化速率;
m_BossHpProgress->setType(ProgressTimer::Type::BAR);//设置进程条的类型;
m_BossHpProgress->setMidpoint(Point(0,0.5));//设置进度的运动方向;
m_BossHpProgress->setPosition(Vec2::ZERO);
bg->addChild(m_BossHpProgress,Z_First);
m_BossHpProgress->setPercentage(90);
//初始化Boss类型;
initType();
m_bossLCA = TDBossLCA :: create(m_nAttackRate);
this->addChild(m_bossLCA);
}
DECLARE_EXPORT SetupMatrix::Rule::Rule(SetupMatrix *s, int p)
: cost(0), priority(p), matrix(s), nextRule(NULL), prevRule(NULL)
{
// Validate the arguments
if (!matrix) throw DataException("Can't add a rule to NULL setup matrix");
// Find the right place in the list
Rule *next = matrix->firstRule, *prev = NULL;
while (next && p > next->priority)
{
prev = next;
next = next->nextRule;
}
// Duplicate priority
if (next && next->priority == p)
throw DataException("Multiple rules with identical priority in setup matrix");
// Maintain linked list
nextRule = next;
prevRule = prev;
if (prev) prev->nextRule = this;
else matrix->firstRule = this;
if (next) next->prevRule = this;
// Initialize the Python type
initType(metadata);
}
FlowPlan::FlowPlan (OperationPlan *opplan, const Flow *f)
: fl(const_cast<Flow*>(f)), oper(opplan)
{
assert(opplan && f);
// Initialize the Python type
initType(metadata);
// Link the flowplan to the operationplan
if (opplan->firstflowplan)
{
// Append to the end
FlowPlan *c = opplan->firstflowplan;
while (c->nextFlowPlan) c = c->nextFlowPlan;
c->nextFlowPlan = this;
}
else
// First in the list
opplan->firstflowplan = this;
// Compute the flowplan quantity
fl->getBuffer()->flowplans.insert(
this,
fl->getFlowplanQuantity(this),
fl->getFlowplanDate(this)
);
// Mark the operation and buffer as having changed. This will trigger the
// recomputation of their problems
fl->getBuffer()->setChanged();
fl->getOperation()->setChanged();
}
ItemSupplier::ItemSupplier()
{
initType(metadata);
// Trigger level and cluster recomputation
HasLevel::triggerLazyRecomputation();
}
DECLARE_EXPORT ItemSupplier::ItemSupplier() : loc(NULL),
size_minimum(1.0), size_multiple(0.0), cost(0.0), firstOperation(NULL)
{
initType(metadata);
// Trigger level and cluster recomputation
HasLevel::triggerLazyRecomputation();
}
PeggingIterator::PeggingIterator(const PeggingIterator& c)
: downstream(c.downstream), firstIteration(c.firstIteration), first(c.first), second_pass(c.second_pass)
{
initType(metadata);
for (statestack::const_iterator i = c.states.begin(); i != c.states.end(); ++i)
states.push_back( state(i->opplan, i->quantity, i->offset, i->level) );
for (deque<state>::const_iterator i = c.states_sorted.begin(); i != c.states_sorted.end(); ++i)
states_sorted.push_back(state(i->opplan, i->quantity, i->offset, i->level));
}
ItemSupplier::ItemSupplier(Supplier* s, Item* r, int u)
{
setSupplier(s);
setItem(r);
setPriority(u);
initType(metadata);
// Trigger level and cluster recomputation
HasLevel::triggerLazyRecomputation();
}
DECLARE_EXPORT ItemSupplier::ItemSupplier(Supplier* s, Item* r, int u)
: loc(NULL), size_minimum(1.0), size_multiple(0.0), cost(0.0), firstOperation(NULL)
{
setSupplier(s);
setItem(r);
setPriority(u);
initType(metadata);
// Trigger level and cluster recomputation
HasLevel::triggerLazyRecomputation();
}
DECLARE_EXPORT PeggingIterator::PeggingIterator(const Demand* d)
: downstream(false), firstIteration(true), first(false)
{
initType(metadata);
const Demand::OperationPlanList &deli = d->getDelivery();
for (Demand::OperationPlanList::const_iterator opplaniter = deli.begin();
opplaniter != deli.end(); ++opplaniter)
{
OperationPlan *t = (*opplaniter)->getTopOwner();
updateStack(t, t->getQuantity(), 0.0, 0);
}
}
PeggingIterator::PeggingIterator(LoadPlan* lp, bool b)
: downstream(b), firstIteration(true), first(false), second_pass(false)
{
initType(metadata);
if (!lp) return;
updateStack(
lp->getOperationPlan()->getTopOwner(),
lp->getOperationPlan()->getQuantity(),
0.0,
0
);
}
DECLARE_EXPORT PeggingIterator::PeggingIterator(FlowPlan* fp, bool b)
: downstream(b), firstIteration(true), first(false)
{
initType(metadata);
if (!fp) return;
updateStack(
fp->getOperationPlan()->getTopOwner(),
fp->getOperationPlan()->getQuantity(),
0.0,
0
);
}
TurnaroundPassenger::TurnaroundPassenger (MobLogEntry& p_entry, CARCportEngine* _pEngine ) :
Passenger (p_entry, _pEngine )
{
MobileElement::setBehavior( new TurnaroundPaxTerminalBehavior( this ));
direction = ARRIVING;
m_logMobEntry = p_entry;
assert( m_pTerm );
arrivingType = initType (p_entry.getArrFlight(), 'A');
arrivingType.SetInputTerminal( m_pTerm );
departingType = initType (p_entry.getDepFlight(), 'D');
departingType.SetInputTerminal( m_pTerm );
Flight *aFlight = getEngine()->m_simFlightSchedule.getItem (p_entry.getArrFlight());
arrivingGate = aFlight->getArrGateIndex();
m_nGate = arrivingGate;
aFlight = getEngine()->m_simFlightSchedule.getItem (p_entry.getDepFlight());
departingGate = aFlight->getDepGateIndex();
departureTime = aFlight->getDepTime();
m_type.setOtherFlightConstraint(arrivingType);
}
DECLARE_EXPORT OperationItemSupplier::OperationItemSupplier(
ItemSupplier* i, Buffer *b
) : supitem(i)
{
if (!i || !b || !i->getSupplier())
throw LogicException(
"An OperationItemSupplier always needs to point to "
"a itemsupplier and a buffer"
);
stringstream o;
o << "Purchase " << b->getName() << " from " << i->getSupplier()->getName();
setName(o.str());
setDuration(i->getLeadTime());
setSizeMultiple(i->getSizeMultiple());
setSizeMinimum(i->getSizeMinimum());
setLocation(b->getLocation());
setSource(i->getSource());
setCost(i->getCost());
setFence(i->getFence());
setHidden(true);
new FlowEnd(this, b, 1);
initType(metadata);
// Optionally, create a load
if (i->getResource())
new LoadDefault(this, i->getResource(), i->getResourceQuantity());
// Insert in the list of ItemSupplier operations.
// We keep the list sorted by the operation name.
if (!i->firstOperation || getName() < i->firstOperation->getName())
{
// New head of the list
nextOperation = i->firstOperation;
i->firstOperation = this;
}
else
{
// Insert in the middle or at the tail
OperationItemSupplier* o = i->firstOperation;
while (o->nextOperation)
{
if (b->getName() < o->nextOperation->getName())
break;
o = o->nextOperation;
}
nextOperation = o->nextOperation;
o->nextOperation = this;
}
}
DECLARE_EXPORT ResourceSkill::ResourceSkill(Skill* s, Resource* r, int u)
{
setSkill(s);
setResource(r);
setPriority(u);
initType(metadata);
try { validate(ADD); }
catch (...)
{
if (getSkill()) getSkill()->resources.erase(this);
if (getResource()) getResource()->skills.erase(this);
resetReferenceCount();
throw;
}
}
DECLARE_EXPORT OperationItemDistribution::OperationItemDistribution(
ItemDistribution* i, Buffer *src, Buffer* dest
) : itemdist(i)
{
if (!i || !src || !dest)
throw LogicException(
"An OperationItemDistribution always needs to point to "
"a ItemDistribution, a source buffer and a destination buffer"
);
stringstream o;
o << "Ship " << dest->getItem()->getName() << " from " << src->getName() << " to " << dest->getName();
setName(o.str());
setDuration(i->getLeadTime());
setSizeMultiple(i->getSizeMultiple());
setSizeMinimum(i->getSizeMinimum());
setLocation(dest->getLocation());
setSource(i->getSource());
setCost(i->getCost());
setHidden(true);
new FlowEnd(this, dest, 1);
new FlowStart(this, src, -1);
initType(metadata);
// Insert in the list of ItemDistribution operations.
// We keep the list sorted by the operation name.
if (!i->firstOperation || getName() < i->firstOperation->getName())
{
// New head of the list
nextOperation = i->firstOperation;
i->firstOperation = this;
}
else
{
// Insert in the middle or at the tail
OperationItemDistribution* o = i->firstOperation;
while (o->nextOperation)
{
if (getName() < o->nextOperation->getName())
break;
o = o->nextOperation;
}
nextOperation = o->nextOperation;
o->nextOperation = this;
}
}
DECLARE_EXPORT LoadPlan::LoadPlan(OperationPlan *o, const Load *r)
{
assert(o);
ld = const_cast<Load*>(r);
oper = o;
start_or_end = START;
// Update the resource field
res = r->getResource();
// Add to the operationplan
nextLoadPlan = NULL;
if (o->firstloadplan)
{
// Append to the end
LoadPlan *c = o->firstloadplan;
while (c->nextLoadPlan) c = c->nextLoadPlan;
c->nextLoadPlan = this;
}
else
// First in the list
o->firstloadplan = this;
// Insert in the resource timeline
getResource()->loadplans.insert(
this,
ld->getLoadplanQuantity(this),
ld->getLoadplanDate(this)
);
// Initialize the Python type
initType(metadata);
// For continuous resources, create a loadplan to mark
// the end of the operationplan.
if (getResource()->getType() != *ResourceBuckets::metadata)
new LoadPlan(o, r, this);
// Mark the operation and resource as being changed. This will trigger
// the recomputation of their problems
getResource()->setChanged();
r->getOperation()->setChanged();
}
PeggingIterator::PeggingIterator(const Demand* d)
: downstream(false), firstIteration(true), first(false), second_pass(false)
{
initType(metadata);
const Demand::OperationPlanList &deli = d->getDelivery();
for (Demand::OperationPlanList::const_iterator opplaniter = deli.begin();
opplaniter != deli.end(); ++opplaniter)
{
OperationPlan *t = (*opplaniter)->getTopOwner();
updateStack(t, t->getQuantity(), 0.0, 0);
}
// Bring all pegging information to a second stack.
// Only in this way can we avoid that the same operationplan is returned
// multiple times
while (operator bool())
{
/** Check if already found in the vector. */
bool found = false;
state& curtop = states.back();
for (deque<state>::iterator it = states_sorted.begin(); it != states_sorted.end() && !found; ++it)
if (it->opplan == curtop.opplan)
{
// Update existing element in sorted stack
it->quantity += curtop.quantity;
if (it->level > curtop.level)
it->level = curtop.level;
found = true;
}
if (!found)
// New element in sorted stack
states_sorted.push_back( state(curtop.opplan, curtop.quantity, curtop.offset, curtop.level) );
if (downstream)
++*this;
else
--*this;
}
// The normal iteration will use the sorted results
second_pass = true;
}
PeggingIterator::PeggingIterator(const OperationPlan* opplan, bool b)
: downstream(b), firstIteration(true), first(false), second_pass(false)
{
initType(metadata);
if (!opplan) return;
if (opplan->getTopOwner()->getOperation()->getType() == *OperationSplit::metadata)
updateStack(
opplan,
opplan->getQuantity(),
0.0,
0
);
else
updateStack(
opplan->getTopOwner(),
opplan->getTopOwner()->getQuantity(),
0.0,
0
);
}
PeggingDemandIterator::PeggingDemandIterator(const OperationPlan* opplan)
{
initType(metadata);
// Walk over all downstream operationplans till demands are found
for (PeggingIterator p(opplan); p; ++p)
{
const OperationPlan* m = p.getOperationPlan();
if (!m)
continue;
Demand* dmd = m->getTopOwner()->getDemand();
if (!dmd || p.getQuantity() < ROUNDING_ERROR)
continue;
map<Demand*, double>::iterator i = dmds.lower_bound(dmd);
if (i != dmds.end() && i->first == dmd)
// Pegging to the same demand multiple times
i->second += p.getQuantity();
else
// Adding demand
dmds.insert(i, make_pair(dmd, p.getQuantity()));
}
}
void
fileIntBindingInit()
{
initType(FileIntType, "FileInt", fileIntFreeInstance);
VALUE klass = rb_define_class("FileInt", rb_cIO);
rb_define_alloc_func(klass, classAllocate<&FileIntType>);
_rb_define_method(klass, "read", fileIntRead);
_rb_define_method(klass, "getbyte", fileIntGetByte);
_rb_define_method(klass, "binmode", fileIntBinmode);
_rb_define_method(klass, "close", fileIntClose);
_rb_define_module_function(rb_mKernel, "load_data", kernelLoadData);
_rb_define_module_function(rb_mKernel, "save_data", kernelSaveData);
/* We overload the built-in 'Marshal::load()' function to silently
* insert our utf8proc that ensures all read strings will be
* UTF-8 encoded */
VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal"));
rb_define_alias(rb_singleton_class(marsh), "_mkxp_load_alias", "load");
_rb_define_module_function(marsh, "load", _marshalLoad);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int EMMPMInputParser::parseCLIArguments(int argc, char* argv[], EMMPM_Data* inputs)
{
if ( NULL == inputs)
{
printf("The EMMPM_Inputs pointer was null. Returning early.\n");
return -1;
}
TCLAP::CmdLine cmd("", ' ', EMMPMLib::Version::Complete().toStdString());
TCLAP::ValueArg<std::string> in_inputFile("i", "inputfile", "Image File to be used as input", true, "", "");
cmd.add(in_inputFile);
TCLAP::ValueArg<std::string> in_outputFile("o", "outputfile", "The Image Output File", true, "", "");
cmd.add(in_outputFile);
TCLAP::ValueArg<float> in_beta("b", "beta", "Beta Value", false, 1.0, "1.0");
cmd.add(in_beta);
TCLAP::ValueArg<float> in_gamma("g", "gamma", "Gamma Value", false, 0.0f, "0.0");
cmd.add(in_gamma);
TCLAP::ValueArg<int> in_emIter("e", "emIter", "Number of EM Iterations", false, 5, "5");
cmd.add(in_emIter);
TCLAP::ValueArg<int> in_mpmIter("m", "mpmIter", "Number of MPM Iterations", false, 5, "5");
cmd.add(in_mpmIter);
TCLAP::ValueArg<int> in_numClasses("n", "numClasses", "The Number of classes or phases in the material", false, 2, "2");
cmd.add(in_numClasses);
TCLAP::SwitchArg in_verbose("v", "verbose", "Verbose Output", false);
cmd.add(in_verbose);
TCLAP::SwitchArg simAnneal("s", "simanneal", "Use Simulated Annealing", false);
cmd.add(simAnneal);
TCLAP::ValueArg<int> initType("z", "inittype", "The initialization algorithm that should be performed", false, 0, "1");
cmd.add(initType);
TCLAP::ValueArg<std::string> initcoords("", "coords", "The upper left (x,y) and lower right (x,y) pixel coordinate sets of each class to be used in the initialization algorithm where each set is separated by a colon ':'. An example is 487,192,507,212:0,332,60,392 for 2 class system.", false, "", "");
cmd.add(initcoords);
TCLAP::ValueArg<std::string> graytable( "", "graytable", "Comma separated list of grayscale values for each class. This can be used to combine classes together at file writing time.", false, "", "");
cmd.add(graytable);
TCLAP::ValueArg<float> beta_e("", "beta_e", "Gradient Penalty Weight", false, 0.0, "0.0");
cmd.add(beta_e);
TCLAP::ValueArg<float> beta_c("", "beta_c", "Curvature Penalty Weight", false, 0.0, "0.0");
cmd.add(beta_c);
TCLAP::ValueArg<float> rmax("", "rmax", "Maximum Radius for Curvature Morphalogical Filter", false, 15.0, "15.0");
cmd.add(rmax);
TCLAP::ValueArg<int> em_loop_delay("", "emLoopDelay", "Number of EM Loops to delay before applying the Morphological Filter", false, 1, "1");
cmd.add(em_loop_delay);
TCLAP::ValueArg<std::string> mv("", "mv", "Pairs of Mean,Sigma initial values for each class where each set is separated by a ':'. Example for 2 classes is: 121.3,22.8:205.2,45.0", false, "", "");
cmd.add(mv);
if (argc < 2)
{
std::cout << "EM/MPM Command Line Version " << cmd.getVersion() << std::endl;
std::vector<std::string> args;
args.push_back(argv[0]);
args.push_back("-h");
cmd.parse(args);
return -1;
}
try
{
int error = 0;
cmd.parse(argc, argv);
inputs->in_beta = in_beta.getValue();
for(int i = 0; i < EMMPM_MAX_CLASSES; i++)
{
inputs->w_gamma[i] = in_gamma.getValue();
}
inputs->mpmIterations = in_mpmIter.getValue();
inputs->emIterations = in_emIter.getValue();
inputs->classes = in_numClasses.getValue();
inputs->verbose = in_verbose.getValue();
inputs->simulatedAnnealing = simAnneal.getValue();
inputs->input_file_name = copyFilenameToNewCharBuffer(in_inputFile.getValue() );
if (inputs->input_file_name == NULL)
{
std::cout << "There was an error parsing the input file name. Did you use the '-i' argument to set an input file?" << std::endl;
return -1;
}
inputs->output_file_name = copyFilenameToNewCharBuffer(in_outputFile.getValue() );
if (inputs->output_file_name == NULL)
{
std::cout << "There was an error parsing the output file name. Did you use the '-o' argument to set an input file?" << std::endl;
return -1;
}
if (inputs->initType == EMMPM_UserInitArea)
{
error = parseInitCoords(initcoords.getValue(), inputs);
if (error < 0)
{
std::cout << "There was an error parsing the command line arguments for the initialization coordinates." << std::endl;
return -1;
}
}
if (inputs->initType == EMMPM_ManualInit)
{
error = parseMuSigmaValues(mv.getValue(), inputs);
if (error < 0)
{
std::cout << "There was an error parsing the command line arguments for the mean and variance values" << std::endl;
return -1;
}
}
if (graytable.getValue().empty() == false)
{
error = parseGrayTable(graytable.getValue(), inputs);
if (error < 0)
{
std::cout << "There was an error parsing the Gray Level Table." << std::endl;
return -1;
}
}
else // Create a default gray level table
{
int n = inputs->classes - 1;
for (int value = 0; value < inputs->classes; ++value)
{
unsigned int argb = 0xFF000000; // Black
unsigned char* ptr = reinterpret_cast<unsigned char*>(&argb);
ptr[1] = value * 255 / n;
ptr[2] = value * 255 / n;
ptr[3] = value * 255 / n;
inputs->colorTable[value] = argb;
}
}
/* Parse the Gradient Penalty Weighting (Beta E) from the command line */
if (beta_e.getValue() > 0.0)
{
inputs->useGradientPenalty = 1;
inputs->beta_e = beta_e.getValue();
}
/* Parse the Curvature Penalty Arguments */
if (beta_c.getValue() > 0.0)
{
inputs->useCurvaturePenalty = 1;
inputs->beta_c = beta_c.getValue();
inputs->r_max = rmax.getValue();
inputs->ccostLoopDelay = em_loop_delay.getValue();
}
}
catch (TCLAP::ArgException& e)
{
std::cerr << " error: " << e.error() << " for arg " << e.argId() << std::endl;
std::cout << "** Unknown Arguments. Displaying help listing instead. **" << std::endl;
return -1;
}
return 0;
}
Vehicule::Vehicule(int deltaT, bool debug) {
if (debug)
std::cout << "Init VE" << std::endl;
soc = 100;
etatMouvActuel = BRANCHE_EN_CHARGE; // BRANCHE_EN_CHARGE
etatMouvSuivant = BRANCHE_EN_CHARGE; // BRANCHE_EN_CHARGE
distanceParcourue = 0;
nbTrajetsEffectues = 0;
willToCharge = true;
typeVehicule = initType();
position = (typeVehicule == VE_PARTICULIER) ? MAISON : TRAVAIL;
modele = initModele(typeVehicule);
capacite = stats_capaciteVehicule[modele];
vitesse = initVitesse(); // en km/h
consommation = capacite / stats_autonomieVehicule[modele];
longueurTrajet = initLongueurTrajet();
puissanceCharge = 3.5;
if (debug)
std::cout << "\t" << "Constantes terminées : VE de type " << typeVehicule << std::endl;
socMin = 0;
nbTrajets = initNbTrajets();
if (debug)
std::cout << "\t" << "Nombre trajets. OK" << std::endl;
for (int h = 0; h < 3; h++) {
accesBornes[h] = false;
}
initAccesBornes(accesBornes, typeVehicule);
if (debug)
std::cout << "\t" << "Accès bornes. OK" << std::endl;
int dernierePosition(position);
int dernierHoraire(0);
bool consistant = true;
if (debug)
std::cout << "\t" << "Calcul des horaires et destinations" << std::endl;
do {
destinations.clear();
horaireDepart.clear();
for (int i(0); i < nbTrajets; i++) {
if (debug)
std::cout << "\t\t" << "Couple n°" << (i+1) << " sur " << nbTrajets << std::endl;
int nouvelHoraire = initHoraireDepart(deltaT, dernierHoraire);
if (debug)
std::cout << "\t\t\t" << "Horaire. OK" << std::endl;
int newDestination = giveDestination(typeVehicule, dernierePosition, nouvelHoraire, deltaT);
if (debug)
std::cout << "\t\t\t" << "Destination. OK" << std::endl;
destinations.push_back(newDestination);
horaireDepart.push_back(nouvelHoraire);
dernierePosition = newDestination;
dernierHoraire = (nouvelHoraire + (int)std::ceil((longueurTrajet / vitesse) * 60 / deltaT)) % (1440/deltaT);
if ((nouvelHoraire + (int)std::ceil((longueurTrajet / vitesse) * 60 / deltaT)) < 1440 / deltaT)
consistant = consistant && true;
else
consistant = false;
}
} while (/*!consistant || */!passeParUneBorne(destinations, accesBornes));
if (debug && !checkOrdreHorairesDepart(horaireDepart))
std::cout << "INCOHERENCE DANS LES HORAIRES" << std::endl;
if (debug)
std::cout << "\t" << "Destinations et horaires départ. OK" << std::endl;
computeSocMin(deltaT);
if (debug) {
std::cout << "\t" << "SOC min. OK" << std::endl;
std::cout << " VE OK !" << std::endl << std::endl;
}
}
PeggingDemandIterator::PeggingDemandIterator(const PeggingDemandIterator& c)
{
initType(metadata);
dmds.insert(c.dmds.begin(), c.dmds.end());
}
