int main(){
std::cout << "Uniform distrution" << std::endl;
printDistrubution(getDistribution([](){return 20.0 * getUniformRandom();}));
std::cout << "\nNormal distrution" << std::endl;
printDistrubution(getDistribution([](){return getNormalRandom(10, 4);}));
}
TestDistributionPostprocessor::TestDistributionPostprocessor(const InputParameters & parameters)
: GeneralPostprocessor(parameters),
_distribution(getDistribution("distribution")),
_cdf_value(getParam<Real>("cdf_value")),
_sample_value(getParam<Real>("sample_value"))
{
}
/**
* The method finds the number of classes and then the delay for each class
*/
Delay *JmtNodeParser::getDelay(TiXmlNode *originalNode) {
if (customerClasses == 1) {
return new Delay(getServiceTimeDistribution(originalNode));
} else {
TiXmlNode *parameterNode = getLowerLevelNodeWith(originalNode, "parameter", "name", "ServiceStrategy");
TiXmlNode *subparametersNode = getLowerLevelNodeWith(parameterNode, "subParameter", "name", "ServiceTimeStrategy");
DistributionSampler **distributionSamplers = new DistributionSampler*[customerClasses];
int classId = 0;
while (subparametersNode != NULL) {
distributionSamplers[classId++] = getDistribution(subparametersNode);
subparametersNode = subparametersNode->NextSibling("subParameter");
}
bool allAreSame = true;
for (int i = 0; i<customerClasses; i++) {
for (int j = i+1; j<customerClasses; j++) {
if(strlen(distributionSamplers[i]->getDistributionSampleType()) != strlen(distributionSamplers[j]->getDistributionSampleType()) || strcmp(distributionSamplers[i]->getDistributionSampleType(), distributionSamplers[j]->getDistributionSampleType()) != 0) {
allAreSame = false;
break;
}
}
}
//
if (allAreSame) {
DistributionSampler *sampler = distributionSamplers[0];
for (int i = 1; i<customerClasses; i++) {
delete distributionSamplers[i];
}
delete[] distributionSamplers;
// cout << "Delay " << sampler->getDistributionSampleType() << " -- " << sampler << endl;
return new Delay(sampler);
} else {
// for (int i = 0; i<customerClasses; i++) {
// cout << "Class dependent delay for class " << i << " " << distributionSamplers[i]->getDistributionSampleType() << " -- " << distributionSamplers[i] << endl;
// }
return new ClassDependentDelay(customerClassesIds, distributionSamplers, customerClasses);
}
// return new Exp(1/0.005);
//
// new ClassDependentDelay()
// TiXmlNode *parameterNode = getLowerLevelNodeWith(originalNode, "parameter", "name", "ServiceStrategy");
}
}
QFFitStatistics QFFCSMaxEntEvaluationItem::calcFitStatistics(QFRawDataRecord *record, int index, int model, double *taus, double* modelValsIn, uint32_t N, uint32_t MaxEntParams, int datacut_min, int datacut_max, int runAvgWidth, int residualHistogramBins) {
QFRDRFCSDataInterface* data=qobject_cast<QFRDRFCSDataInterface*>(record);
if (data) {
double* corrdata=data->getCorrelationMean();
if (index>=0) corrdata=data->getCorrelationRun(index);
double* modelVals=modelValsIn;
bool freeModelVals=false;
if (!modelVals) {
modelVals=(double*)qfMalloc(N*sizeof(double));
QVector<double> dist=getDistribution(record, index, model);
QVector<double> distTau=getDistributionTaus(record, index, model);
evaluateModel(record, index, model, taus, modelVals, N, distTau.data(), dist.data(), dist.size());
freeModelVals=true;
}
//double* modelVals=(double*)qfMalloc(N*sizeof(double));
//
//(record, index, model, taus, modelVals, N);
double* weights=allocWeights(NULL, record, index);
QFFitStatistics result= calculateFitStatistics(N, taus, modelVals, corrdata, weights, datacut_min, datacut_max, MaxEntParams, runAvgWidth, residualHistogramBins);
if (record) {
if (hasResults(record, index)) {
setFitResultFitStatistics(record, index, model, result, "fitstat_", tr("fit statistics"));
}
}
qfFree(weights);
if (freeModelVals) qfFree(modelVals);
return result;
}
return QFFitStatistics();
}
void ConfigurationDefault::updateParameters(const std::vector<Obs>& iObs, int iDate, int iInit, float iOffset, int iPoolId, const std::string& iVariable, int iDateGet, int iDateSet, float iOffsetGet, float iOffsetSet) {
const std::vector<Obs>& useObs = iObs;
int dateFcst = iDate;
float offset = iOffset;
int poolId = iPoolId;
iDate = iDateGet;
bool needEnsemble = getNeedEnsemble();
// Check that we are updating the right forecast
for(int k = 0; k < useObs.size(); k++) {
Obs obs = useObs[k];
assert(Global::getDate(obs.getDate(), obs.getInit(), obs.getOffset()) == Global::getDate(dateFcst, iInit, offset) &&
Global::getTime(obs.getDate(), obs.getInit(), obs.getOffset()) == Global::getTime(dateFcst, iInit, offset));
}
// Selector
if(mSelector->needsTraining()) {
Parameters par;
getParameters(Processor::TypeSelector, iDate, iInit, iOffsetGet, poolId, iVariable, 0, par);
// Create vector date and offsets for selector's update parameters
std::vector<int> fcstDates(iObs.size(), iDate);
std::vector<float> fcstOffsets(iObs.size(), iOffset);
mSelector->updateParameters(fcstDates, iInit, fcstOffsets, useObs, par);
setParameters(Processor::TypeSelector, iDate, iInit, iOffsetSet, poolId, iVariable, 0, par);
}
if(needEnsemble) {
// Correctors
std::vector<Ensemble> ensembles;
for(int n = 0; n < useObs.size(); n++) {
Location obsLocation = useObs[n].getLocation();
// Get the raw ensemble
Ensemble ensemble;
getEnsemble(dateFcst, iInit, offset, obsLocation, iVariable, ensemble, typeUnCorrected);
ensembles.push_back(ensemble);
}
for(int k = 0; k < (int) mCorrectors.size(); k++) {
Parameters parCorrector;
getParameters(Processor::TypeCorrector, iDate, iInit, iOffsetGet, poolId, iVariable, k, parCorrector);
Parameters parOrig = parCorrector;
if(mCorrectors[k]->needsTraining()) {
mCorrectors[k]->updateParameters(ensembles, useObs, parCorrector);
setParameters(Processor::TypeCorrector, iDate, iInit, iOffsetSet, poolId, iVariable, k, parCorrector);
}
// Correct ensemble for next corrector
for(int n = 0; n < ensembles.size(); n++) {
mCorrectors[k]->correct(parOrig, ensembles[n]);
}
}
// Uncertainty
Parameters parUncertainty;
getParameters(Processor::TypeUncertainty, iDate, iInit, iOffsetGet, poolId, iVariable, 0, parUncertainty);
Parameters parAverager;
getParameters(Processor::TypeAverager, iDate, iInit, iOffsetGet, poolId, iVariable, 0, parAverager);
if(mUncertainty->needsTraining()) {
mUncertainty->updateParameters(ensembles, useObs, parUncertainty);
setParameters(Processor::TypeUncertainty, iDate, iInit, iOffsetSet, poolId, iVariable, 0, parUncertainty);
}
// Calibrators
if(mAverager->needsTraining() || mCalibrators.size() > 0 || mUpdaters.size() > 0) {
std::vector<std::vector<Distribution::ptr> > upstreams;
upstreams.resize(1 + mCalibrators.size() + mUpdaters.size());
upstreams[0].resize(useObs.size());
for(int n = 0; n < useObs.size(); n++) {
Distribution::ptr uncD = mUncertainty->getDistribution(ensembles[n], parUncertainty, *mAverager, parAverager);
upstreams[0][n] = uncD;
}
// Start with the uncertainty distributions. Then iteratively calibrate the previous
// distirbution (upstream).
int Iupstream = 0;
for(int k = 0; k < (int) mCalibrators.size(); k++) {
upstreams[Iupstream+1].resize(useObs.size());
Parameters parCalibrator;
getParameters(Processor::TypeCalibrator, iDate, iInit, iOffsetGet, poolId, iVariable, k, parCalibrator);
if(mCalibrators[k]->needsTraining()) {
mCalibrators[k]->updateParameters(upstreams[Iupstream], useObs, parCalibrator);
setParameters(Processor::TypeCalibrator, iDate, iInit, iOffsetSet, poolId, iVariable, k, parCalibrator);
}
// Calibrate all distributions for the next calibrator
for(int n = 0; n < useObs.size(); n++) {
upstreams[Iupstream+1][n] = mCalibrators[k]->getDistribution(upstreams[Iupstream][n], parCalibrator);
}
Iupstream++;
}
// Updaters
if(mUpdaters.size() > 0) {
assert(mUpdaters.size() <= 1);
std::vector<Distribution::ptr> recentDists(useObs.size());
std::vector<Obs> recentObs;
for(int n = 0; n < useObs.size(); n++) {
Distribution::ptr recentDist = getDistribution(dateFcst, iInit, 0, useObs[n].getLocation(), iVariable, typeUnUpdated);
recentDists[n] = recentDist;
// Get the recent most observation
Obs obs;
mData.getObs(dateFcst, iInit, 0, useObs[n].getLocation(), iVariable, obs);
recentObs.push_back(obs);
}
for(int k = 0; k < mUpdaters.size(); k++) {
upstreams[Iupstream+1].resize(useObs.size());
Parameters par;
getParameters(Processor::TypeUpdater, iDate, iInit, iOffsetGet, poolId, iVariable, k, par);
if(mUpdaters[k]->needsTraining()) {
mUpdaters[k]->updateParameters(upstreams[Iupstream], useObs, recentDists, recentObs, par);
setParameters(Processor::TypeUpdater, iDate, iInit, iOffsetSet, poolId, iVariable, k, par);
}
Iupstream++;
}
}
// Averager
if(mAverager->needsTraining()) {
Parameters parAverager;
getParameters(Processor::TypeAverager, iDate, iInit, iOffsetGet, poolId, iVariable, 0, parAverager);
mAverager->updateParameters(upstreams[upstreams.size()-1], useObs, parAverager);
setParameters(Processor::TypeAverager, iDate, iInit, iOffsetSet, poolId, iVariable, 0, parAverager);
}
}
}
}
Distribution::ptr ConfigurationDefault::getDistribution(int iDate,
int iInit,
float iOffset,
const Location& iLocation,
std::string iVariable,
ProcTypeDist iType) const {
float offsetCode = mPooler->find(iOffset);
Ensemble ens;
getEnsemble(iDate, iInit, iOffset, iLocation, iVariable, ens);
/////////////////
// Uncertainty //
/////////////////
Parameters parUnc;
getParameters(Processor::TypeUncertainty, iDate, iInit, offsetCode, iLocation, iVariable, 0, parUnc);
Parameters parAverager;
getParameters(Processor::TypeAverager, iDate, iInit, offsetCode, iLocation, iVariable, 0, parAverager);
Distribution::ptr uncD = mUncertainty->getDistribution(ens, parUnc, *mAverager, parAverager);
if(mCalibrators.size() == 0 && mUpdaters.size() == 0)
return uncD;
if(iType == typeUnCalibrated)
return uncD;
/////////////////
// Calibration //
/////////////////
std::vector<Distribution::ptr> cal;
cal.push_back(uncD);
// Chain calibrators together
for(int i = 0; i < (int) mCalibrators.size(); i++) {
Parameters parCal;
getParameters(Processor::TypeCalibrator, iDate, iInit, offsetCode, iLocation, iVariable, i, parCal);
cal.push_back(mCalibrators[i]->getDistribution(cal[i], parCal));
}
if(iType == typeUnUpdated)
return cal.back();
//////////////
// Updating //
//////////////
for(int i = 0; i < (int) mUpdaters.size(); i++) {
Parameters par;
Obs recentObs;
mData.getObs(iDate, iInit, 0, iLocation, iVariable, recentObs);
Distribution::ptr recentDist = getDistribution(iDate, iInit, 0, iLocation, iVariable, typeUnUpdated);
getParameters(Processor::TypeUpdater, iDate, iInit, offsetCode, iLocation, iVariable, i, par);
int Iupstream = cal.size()-1;
assert(Iupstream >= 0);
Distribution::ptr dist = mUpdaters[i]->getDistribution(cal[Iupstream], recentObs, recentDist, par);
cal.push_back(dist);
}
return cal.back();
}
void distributionFunctionObject::write() {
clearDistributions();
getDistribution();
if(writeTimeline() && startup_) {
timelineFunctionObject::start();
}
startup_=false;
bool zeroDistribution=false;
if(
distScalar_.valid()
&&
distScalar_->maxNrBins()<=0
) {
zeroDistribution=true;
}
if(
distVector_.valid()
&&
distVector_->maxNrBins()<=0
) {
zeroDistribution=true;
}
if(
distTensor_.valid()
&&
distTensor_->maxNrBins()<=0
) {
zeroDistribution=true;
}
if(
distSymmTensor_.valid()
&&
distSymmTensor_->maxNrBins()<=0
) {
zeroDistribution=true;
}
if(
distSphericalTensor_.valid()
&&
distSphericalTensor_->maxNrBins()<=0
) {
zeroDistribution=true;
}
if(zeroDistribution) {
WarningIn("distributionFunctionObject::write")
<< "Distribution for " << name() << " has size 0. "
<< "Doing nothing"
<< endl;
return;
}
if(Pstream::master()) {
if(writeTimeline()) {
writeATimeline(distScalar_);
writeATimeline(distVector_);
writeATimeline(distTensor_);
writeATimeline(distSymmTensor_);
writeATimeline(distSphericalTensor_);
}
if(writeDistribution()) {
writeADistribution(distScalar_);
writeADistribution(distVector_);
writeADistribution(distTensor_);
writeADistribution(distSymmTensor_);
writeADistribution(distSphericalTensor_);
}
if(verbose()) {
reportADistribution(distScalar_);
reportADistribution(distVector_);
reportADistribution(distTensor_);
reportADistribution(distSymmTensor_);
reportADistribution(distSphericalTensor_);
}
}
}
Boolean UNIX_ApplicationSystem::getDistribution(CIMProperty &p) const
{
p = CIMProperty(PROPERTY_DISTRIBUTION, getDistribution());
return true;
}
