FileArome::FileArome(std::string iFilename, bool iReadOnly) : FileNetcdf(iFilename, iReadOnly) {
// Set dimensions
NcDim* dTime = getDim("time");
NcDim* dLon = getDim("x");
NcDim* dLat = getDim("y");
mNTime = dTime->size();
mNLat = dLat->size();
mNLon = dLon->size();
mNEns = 1;
mLats = getLatLonVariable("latitude");
mLons = getLatLonVariable("longitude");
if(hasVariableCore("surface_geopotential")) {
FieldPtr elevField = getFieldCore("surface_geopotential", 0);
mElevs.resize(getNumLat());
for(int i = 0; i < getNumLat(); i++) {
mElevs[i].resize(getNumLon());
for(int j = 0; j < getNumLon(); j++) {
float value = (*elevField)(i,j,0) / 9.81;
mElevs[i][j] = value;
}
}
std::cout << "Deriving altitude from geopotential height in " << getFilename() << std::endl;
}
else {
mElevs = getLatLonVariable("altitude");
}
if(hasVar("time")) {
NcVar* vTime = getVar("time");
double* times = new double[mNTime];
vTime->get(times , mNTime);
setTimes(std::vector<double>(times, times+mNTime));
delete[] times;
}
else {
std::vector<double> times;
times.resize(getNumTime(), Util::MV);
setTimes(times);
}
if(hasVar("forecast_reference_time")) {
NcVar* vReferenceTime = getVar("forecast_reference_time");
double referenceTime = getReferenceTime();
vReferenceTime->get(&referenceTime, 1);
setReferenceTime(referenceTime);
}
Util::status( "File '" + iFilename + " 'has dimensions " + getDimenionString());
}
void InterfaceHandler::setTimes(bool isBlacksTurn, float time, int stones)
{
QString strTime;
int seconds = (int)time;
bool neg = seconds < 0;
if (neg)
seconds = -seconds;
int h = seconds / 3600;
seconds -= h*3600;
int m = seconds / 60;
int s = seconds - m*60;
QString sec;
// prevailling 0 for seconds
if ((h || m) && s < 10)
sec = "0" + QString::number(s);
else
sec = QString::number(s);
if (h)
{
QString min;
// prevailling 0 for minutes
if (h && m < 10)
min = "0" + QString::number(m);
else
min = QString::number(m);
strTime = (neg ? "-" : "") + QString::number(h) + ":" + min + ":" + sec;
}
else
strTime = (neg ? "-" : "") + QString::number(m) + ":" + sec;
if (isBlacksTurn)
setTimes(strTime, QString::number(stones), 0, 0);
else
setTimes(0, 0, strTime, QString::number(stones));
}
/*
* COMMAND CENTRE
*/
String Controller::doCommand(String string)
{
//Log.Debug("Command: %s", string);
String s = NULL;
int i = (int) stringToTime(string);
char command;
if (string.length() > 0)
{
command = string.charAt(0);
}
else
{
return s;
}
switch (command)
{
case 'A': // status request only
break;
case 'L': // move left
moveLeft(i);
break;
case 'R': // move right
moveRight(i);
break;
case 'I': // update interval
setInterval(i);
break;
case 'J': // update step size
setStepSize(i);
break;
case 'S': // update start/end/rewind times
setTimes(string);
break;
case 'T': // update date and time
setTimestamp(stringToTime(string));
break;
default: // returns NULL
return s;
}
s = getStatus();
return s;
}
Optimization::Optimization( unsigned int firstPoint,
unsigned int lastPoint,
QList<FlightPoint*> ptr_route,
QProgressBar *progressBar ) :
QObject(0),
original_route( ptr_route ),
progress( progressBar )
{
Q_UNUSED( firstPoint)
Q_UNUSED( lastPoint )
setTimes( 0, original_route.count() );
optimized = false;
progress = progressBar;
stopit = false;
start = 0;
stop = original_route.count();
}
FwdPeriodAdapter::FwdPeriodAdapter(
const ext::shared_ptr<MarketModel>& largeModel,
Size period,
Size offset,
const std::vector<Spread>& newDisplacements)
:
numberOfFactors_(largeModel->numberOfFactors()),
numberOfRates_((largeModel->numberOfRates()-offset) / (period > 0 ? period : 1) ),
numberOfSteps_(largeModel->numberOfSteps()),
pseudoRoots_(numberOfSteps_, Matrix(numberOfRates_,
numberOfFactors_)),
displacements_(newDisplacements)
{
QL_REQUIRE( period >0, "period must be greater than zero in fwdperiodadapter");
QL_REQUIRE(period > offset, "period must be greater than offset in fwdperiodadapter");
const std::vector<Spread>& largeDisplacements_ =
largeModel->displacements();
if (displacements_.size() == 1)
{
Real dis = displacements_[0];
displacements_.resize(numberOfRates_);
std::fill(displacements_.begin(), displacements_.end(), dis);
}
if (displacements_.size() ==0) // if not specified use average across rate
{
displacements_.reserve(numberOfRates_);
Size m=0;
Real sum=0.0;
for (Size k=0; k < numberOfRates_; ++k)
{
for (Size l=0; l < period; ++l, ++m)
sum+= largeDisplacements_[m];
displacements_.push_back(sum/period);
}
}
QL_REQUIRE( displacements_.size() == numberOfRates_,"newDisplacements should be empty,1, or number of new rates in fwdperiodadapter");
LMMCurveState largeCS(largeModel->evolution().rateTimes());
largeCS.setOnForwardRates(largeModel->initialRates());
LMMCurveState smallCS(
ForwardForwardMappings::RestrictCurveState(largeCS,
period, offset
));
initialRates_ =smallCS.forwardRates();
Real finalReset = smallCS.rateTimes()[smallCS.numberOfRates()-1];
std::vector<Time> oldEvolutionTimes(largeModel->evolution().evolutionTimes());
std::vector<Time> newEvolutionTimes;
for (Size i =0; i < oldEvolutionTimes.size() && oldEvolutionTimes[i]<= finalReset; ++i)
newEvolutionTimes.push_back(oldEvolutionTimes[i]);
evolution_=EvolutionDescription(smallCS.rateTimes(),
newEvolutionTimes);
numberOfSteps_ = newEvolutionTimes.size();
const std::vector<Time>& rateTimes =
smallCS.rateTimes();
// we must ensure we step through all rateTimes
const std::vector<Time>& evolutionTimes =
evolution_.evolutionTimes();
std::set<Time> setTimes(evolutionTimes.begin(),evolutionTimes.end());
for (Size i=0; i < rateTimes.size()-1; ++i)
QL_REQUIRE(setTimes.find(rateTimes[i]) != setTimes.end(),
"every new rate time except last must be an evolution time in fwdperiod adapter");
Matrix YMatrix =
ForwardForwardMappings::YMatrix( largeCS,
largeDisplacements_,
displacements_,
period,
offset
);
const std::vector<Size>& alive =
evolution_.firstAliveRate();
for (Size k = 0; k<numberOfSteps_; ++k) {
pseudoRoots_[k]=YMatrix*largeModel->pseudoRoot(k);
for (Size i=0; i<alive[k]; ++i)
std::fill(pseudoRoots_[k].row_begin(i),
pseudoRoots_[k].row_end(i),
0.0);
}
}
