void Instrument::sumResults(QList<Array*> arrays) { PeerToPeerCommunicator* comm = find<PeerToPeerCommunicator>(); Log* log = find<Log>(); TimeLogger logger(log->verbose() && comm->isMultiProc() ? log : 0, "communication of the observed fluxes"); foreach (Array* arr, arrays) if (arr->size()) comm->sum(*arr); }
void PanDustSystem::sumResults(bool ynstellar) { // Get a pointer to the PeerToPeerCommunicator of this simulation PeerToPeerCommunicator * comm = find<PeerToPeerCommunicator>(); Log* log = find<Log>(); TimeLogger logger(log->verbose() && comm->isMultiProc() ? log : 0, "communication of the absorbed luminosities"); // Sum the array of luminosities across all processes comm->sum_all(ynstellar ? _Labsstelvv.getArray() : _Labsdustvv.getArray()); }
double PanDustSystem::Labsdusttot() const { double sum = 0; if (_haveLabsdust) for (int m=0; m<_Ncells; m++) for (int ell=0; ell<_Nlambda; ell++) sum += _Labsdustvv(m,ell); PeerToPeerCommunicator * comm = find<PeerToPeerCommunicator>(); Array arr(1); arr[0] = sum; comm->sum_all(arr); return arr[0]; }
void InstrumentFrame::calibrateAndWriteDataFrames(int ell, QList<Array*> farrays, QStringList fnames) { PeerToPeerCommunicator* comm = find<PeerToPeerCommunicator>(); if (!comm->isRoot()) return; Units* units = find<Units>(); WavelengthGrid* lambdagrid = find<WavelengthGrid>(); // conversion from bolometric luminosities (units W) to monochromatic luminosities (units W/m) // --> divide by delta-lambda double dlambda = lambdagrid->dlambda(ell); // correction for the area of the pixels of the images; the units are now W/m/sr // --> divide by area double xpresang = 2.0*atan(_xpres/(2.0*_distance)); double ypresang = 2.0*atan(_ypres/(2.0*_distance)); double area = xpresang*ypresang; // calibration step 3: conversion of the flux per pixel from monochromatic luminosity units (W/m/sr) // to flux density units (W/m3/sr) by taking into account the distance // --> divide by fourpid2 double fourpid2 = 4.0*M_PI*_distance*_distance; // conversion from program SI units (at this moment W/m3/sr) to the correct output units // --> multiply by unit conversion factor double unitfactor = units->osurfacebrightness(lambdagrid->lambda(ell), 1.); // perform the conversion, in place foreach (Array* farr, farrays) { (*farr) *= (unitfactor / (dlambda * area * fourpid2)); } // write a FITS file for each array for (int q = 0; q < farrays.size(); q++) { QString filename = find<FilePaths>()->output(_instrument->instrumentName() + "_" + fnames[q] + "_" + QString::number(ell) + ".fits"); find<Log>()->info("Writing " + fnames[q] + " flux " + QString::number(ell) + " to FITS file " + filename + "..."); FITSInOut::write(filename, *(farrays[q]), _Nxp, _Nyp, 1, units->olength(_xpres), units->olength(_ypres), units->usurfacebrightness(), units->ulength()); } }
void Image::saveto(const SimulationItem* item, const Array& data, QString filename, QString description) { // Cache a pointer to the logger Log* log = item->find<Log>(); // Determine the path of the output FITS file QString filepath = item->find<FilePaths>()->output(filename.endsWith(".fits") ? filename : filename + ".fits"); // Try to find a PeerToPeerCommunicator object PeerToPeerCommunicator* comm = 0; try {comm = item->find<PeerToPeerCommunicator>();} catch (FatalError) {} // Only write the FITS file if this process is the root or no PeerToPeerCommunicator was found if (!comm || comm->isRoot()) { log->info("Writing " + description + " to " + filepath + "..."); FITSInOut::write(filepath, data, _xsize, _ysize, _nframes, _incx, _incy, _xc, _yc, _dataunits, _xyunits); } }
void PanDustSystem::write() const { DustSystem::write(); PeerToPeerCommunicator* comm = find<PeerToPeerCommunicator>(); bool dataParallel = comm->dataParallel(); // If requested, output the interstellar radiation field in every dust cell to a data file if (_writeISRF) { WavelengthGrid* lambdagrid = find<WavelengthGrid>(); Units* units = find<Units>(); // Create a text file TextOutFile file(this, "ds_isrf", "ISRF"); // Write the header file.writeLine("# Mean field intensities for all dust cells with nonzero absorption"); file.addColumn("dust cell index", 'd'); file.addColumn("x coordinate of cell center (" + units->ulength() + ")", 'g'); file.addColumn("y coordinate of cell center (" + units->ulength() + ")", 'g'); file.addColumn("z coordinate of cell center (" + units->ulength() + ")", 'g'); for (int ell=0; ell<_Nlambda; ell++) file.addColumn("J_lambda (W/m3/sr) for lambda = " + QString::number(units->owavelength(lambdagrid->lambda(ell))) + " " + units->uwavelength(), 'g'); // Write one line for each dust cell with nonzero absorption for (int m=0; m<_Ncells; m++) { if (!dataParallel) { double Ltotm = Labs(m); if (Ltotm>0.0) { QList<double> values; Position bfr = _grid->centralPositionInCell(m); values << m << units->olength(bfr.x()) << units->olength(bfr.y()) << units->olength(bfr.z()); for (auto J : meanintensityv(m)) values << J; file.writeRow(values); } } else // for distributed mode { QList<double> values; Position bfr = _grid->centralPositionInCell(m); values << m << units->olength(bfr.x()) << units->olength(bfr.y()) << units->olength(bfr.z()); // the correct process gets Jv Array Jv(_Nlambda); if (_assigner->validIndex(m)) Jv = meanintensityv(m); // and broadcasts it int sender = _assigner->rankForIndex(m); comm->broadcast(Jv,sender); if (Jv.sum()>0) { for (auto J : Jv) values << J; file.writeRow(values); } } } } // If requested, output temperature map(s) along coordinate axes and temperature data for each dust cell if (_writeTemp) { // Parallelize the calculation over the threads Parallel* parallel = find<ParallelFactory>()->parallel(); // If the necessary data is distributed over the processes, do the calculation on all processes. // Else, let the root do everything. bool isRoot = comm->isRoot(); // Output temperature map(s) along coordinate axes { // Construct a private class instance to do the work (parallelized) WriteTempCut wt(this); // Get the dimension of the dust grid int dimDust = _grid->dimension(); // For the xy plane (always) { wt.setup(1,1,0); if (dataParallel) parallel->call(&wt, Np); else if (isRoot) parallel->call(&wt, Np); wt.write(); } // For the xz plane (only if dimension is at least 2) if (dimDust >= 2) { wt.setup(1,0,1); if (dataParallel) parallel->call(&wt, Np); else if (isRoot) parallel->call(&wt, Np); wt.write(); } // For the yz plane (only if dimension is 3) if (dimDust == 3) { wt.setup(0,1,1); if (dataParallel) parallel->call(&wt, Np); else if (isRoot) parallel->call(&wt, Np); wt.write(); } } // Output a text file with temperature data for each dust cell { find<Log>()->info("Calculating indicative dust temperatures for each cell..."); // Construct a private class instance to do the work (parallelized) WriteTempData wt(this); // Call the body on the right cells. If everything is available, no unnecessary communication will be done. if (dataParallel) { // Calculate the temperature for the cells owned by this process parallel->call(&wt, _assigner); } else if (isRoot) { // Let root calculate it for everything parallel->call(&wt, _Ncells); } wt.write(); } } }
void PanDustSystem::setupSelfAfter() { DustSystem::setupSelfAfter(); PeerToPeerCommunicator* comm = find<PeerToPeerCommunicator>(); bool dataParallel = comm->dataParallel(); if (dataParallel) // assign this process to work with a subset of dust cells _assigner = new StaggeredAssigner(_Ncells, this); WavelengthGrid* wg = find<WavelengthGrid>(); // resize the tables that hold the absorbed energies for each dust cell and wavelength // - absorbed stellar emission is relevant for calculating dust emission // - absorbed dust emission is relevant for calculating dust self-absorption _haveLabsStel = false; _haveLabsDust = false; if (dustemission()) { if (dataParallel) _LabsStelvv.initialize("Absorbed Stellar Luminosity Table", ParallelTable::WriteState::COLUMN, wg->assigner(), _assigner, comm); else _LabsStelvv.initialize("Absorbed Stellar Luminosity Table", ParallelTable::WriteState::COLUMN, _Nlambda, _Ncells, comm); _haveLabsStel = true; if (selfAbsorption()) { if (dataParallel) _LabsDustvv.initialize("Absorbed Dust Luminosity Table", ParallelTable::WriteState::COLUMN, wg->assigner(), _assigner, comm); else _LabsDustvv.initialize("Absorbed Dust Luminosity Table", ParallelTable::WriteState::COLUMN, _Nlambda, _Ncells, comm); _haveLabsDust = true; } } // write emissivities if so requested if (writeEmissivity()) { // write emissivities for a range of scaled Mathis ISRF input fields Array Jv = ISRF::mathis(this); for (int i=-4; i<7; i++) { double U = pow(10.,i); writeEmissivitiesForField(this, U*Jv, "Mathis_U_" + QString::number(U,'e',0), QString::number(U) + " * Mathis ISRF"); } // write emissivities for a range of diluted Black Body input fields const int Tv[] = { 3000, 6000, 9000, 12000, 15000, 18000 }; const double Dv[] = { 8.28e-12, 2.23e-13, 2.99e-14, 7.23e-15, 2.36e-15, 9.42e-16 }; for (int i=0; i<6; i++) { Jv = Dv[i] * ISRF::blackbody(this, Tv[i]); writeEmissivitiesForField(this, Jv, QString("BlackBody_T_%1").arg(Tv[i], 5, 10, QChar('0')), QString("%1 * B(%2K)").arg(Dv[i],0,'e',2).arg(Tv[i]) ); } find<Log>()->info("Done writing emissivities."); } }