void Calibrator::initialize() {
pUncalibratedData = new Datum(M_LIST, this->getNumInputs() );
pSampledData = new Datum(M_LIST, this->getNumInputs() );
pCalibratedData = new Datum(M_LIST, this->getNumOutputs() );
fitableFunctions = new ExpandableList<FitableFunction>( this->getNumOutputs() );
// set vectors to 0 as defaults
for (int i = 0; i < this->getNumInputs(); i++) {
pUncalibratedData->setElement(i, (double)0);
pSampledData->setElement(i, (double)0);
}
for (int i = 0; i < this->getNumOutputs(); i++) {
pCalibratedData->setElement(i, (double)0);
}
// create an averager for each input line (also feeds off the input variable)
averagers = new ExpandableList<Averager>( this->getNumInputs() );
shared_ptr<Variable> inputVariable;
for (int inputIndex=0;inputIndex<this->getNumInputs();inputIndex++) {
if (this->getInputVariable(inputIndex, &inputVariable)) {
shared_ptr<Averager> averager(new Averager(inputVariable));
averagers->addReference(inputIndex, averager);
}
}
// announce the presence of the calibrator
Datum announceData(M_DICTIONARY, 2);
announceData.addElement(CALIBRATOR_NAME,uniqueCalibratorName); // char
announceData.addElement(CALIBRATOR_ACTION,CALIBRATOR_ACTION_IDENTIFY_SELF);
announce(announceData); // announce things here using method from Announcable
initialized = true;
}
MGLevelOp<LevelData<FArrayBox> >* VCAMRPoissonOp2Factory::MGnewOp(const ProblemDomain& a_indexSpace,
int a_depth,
bool a_homoOnly)
{
CH_TIME("VCAMRPoissonOp2Factory::MGnewOp");
Real dxCrse = -1.0;
int ref;
for (ref = 0; ref < m_domains.size(); ref++)
{
if (a_indexSpace.domainBox() == m_domains[ref].domainBox())
{
break;
}
}
CH_assert(ref != m_domains.size()); // didn't find domain
if (ref > 0)
{
dxCrse = m_dx[ref-1];
}
ProblemDomain domain(m_domains[ref]);
Real dx = m_dx[ref];
int coarsening = 1;
for (int i = 0; i < a_depth; i++)
{
coarsening *= 2;
domain.coarsen(2);
}
if (coarsening > 1 && !m_boxes[ref].coarsenable(coarsening*VCAMRPoissonOp2::s_maxCoarse))
{
return NULL;
}
dx *= coarsening;
DisjointBoxLayout layout;
coarsen_dbl(layout, m_boxes[ref], coarsening);
Copier ex = m_exchangeCopiers[ref];
CFRegion cfregion = m_cfregion[ref];
if (coarsening > 1)
{
ex.coarsen(coarsening);
cfregion.coarsen(coarsening);
}
VCAMRPoissonOp2* newOp = new VCAMRPoissonOp2;
newOp->define(layout, dx, domain, m_bc, ex, cfregion);
newOp->m_alpha = m_alpha;
newOp->m_beta = m_beta;
if (a_depth == 0)
{
// don't need to coarsen anything for this
newOp->m_aCoef = m_aCoef[ref];
newOp->m_bCoef = m_bCoef[ref];
}
else
{
// need to coarsen coefficients
RefCountedPtr<LevelData<FArrayBox> > aCoef( new LevelData<FArrayBox> );
RefCountedPtr<LevelData<FluxBox> > bCoef( new LevelData<FluxBox> );
aCoef->define(layout, m_aCoef[ref]->nComp(), m_aCoef[ref]->ghostVect());
bCoef->define(layout, m_bCoef[ref]->nComp(), m_bCoef[ref]->ghostVect());
// average coefficients to coarser level
// for now, do this with a CoarseAverage --
// may want to switch to harmonic averaging at some point
CoarseAverage averager(m_aCoef[ref]->getBoxes(),
layout, aCoef->nComp(), coarsening);
CoarseAverageFace faceAverager(m_bCoef[ref]->getBoxes(),
bCoef->nComp(), coarsening);
if (m_coefficient_average_type == CoarseAverage::arithmetic)
{
averager.averageToCoarse(*aCoef, *(m_aCoef[ref]));
faceAverager.averageToCoarse(*bCoef, *(m_bCoef[ref]));
}
else if (m_coefficient_average_type == CoarseAverage::harmonic)
{
averager.averageToCoarseHarmonic(*aCoef, *(m_aCoef[ref]));
faceAverager.averageToCoarseHarmonic(*bCoef, *(m_bCoef[ref]));
}
else
{
MayDay::Abort("VCAMRPoissonOp2Factory::MGNewOp -- bad averagetype");
}
newOp->m_aCoef = aCoef;
newOp->m_bCoef = bCoef;
}
newOp->computeLambda();
newOp->m_dxCrse = dxCrse;
return (MGLevelOp<LevelData<FArrayBox> >*)newOp;
}
