common.C File Reference

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <ctype.h>
#include "common.h"
#include "Node.h"
#include "SimParameters.h"
#include "InfoStream.h"
#include "charm++.h"

Go to the source code of this file.

Functions
const char *	NAMD_version_string ()
void	NAMD_version (int *major, int *minor, int *patchLevel, int *releaseType)
int	NAMD_gcd (int a, int b)
char *	NAMD_stringdup (const char *s)
void	NAMD_quit (const char *err_msg)
void	NAMD_die (const char *err_msg)
void	NAMD_err (const char *err_msg)
void	NAMD_bug (const char *err_msg)
int	NAMD_file_exists (const char *filename)
void	NAMD_backup_file (const char *filename, const char *extension)
int	NAMD_open_text (const char *fname, int append)
void	NAMD_write (int fd, const char *buf, size_t count, const char *fname)
void	NAMD_close (int fd, const char *fname)
FILE *	Fopen (const char *filename, const char *mode)
int	Fclose (FILE *fout)

Function Documentation

Fclose()

int Fclose

(

FILE *

fout

)

Definition at line 436 of file common.C.

Referenced by ConfigList::ConfigList(), Ambertoppar::genclose(), PDB::PDB(), read_binary_file(), and Parameters::read_parameter_file().

{
  int rc = -1;
#if !defined(NOCOMPRESSED)
  rc = pclose(fout);
#endif
  if (rc == -1) // stream not associated with a popen()
    {
    rc = fclose(fout);
    }
  return rc;
} /* Fclose() */

Fopen()

FILE* Fopen	(	const char *	filename,
		const char *	mode
	)

Definition at line 342 of file common.C.

References endi(), and iout.

Referenced by ConfigList::ConfigList(), Ambertoppar::genopen(), GridforceFullMainGrid::initialize(), PDB::PDB(), read_binary_file(), and Parameters::read_parameter_file().

{
  struct stat buf;
  // check if basic filename exists (and not a directory)

#if defined(NOCOMPRESSED)
  if (!stat(filename,&buf))
    {
      FILE *rval;
      while ( ! (rval = fopen(filename,mode)) ) {
        if ( errno != EINTR ) break;
      }
      return(rval);
    }
#else
  if (!stat(filename,&buf))
    {
      if (!S_ISDIR(buf.st_mode)) {
        FILE *rval;
        while ( ! (rval = fopen(filename,mode)) ) {
          if ( errno != EINTR ) break;
        }
        return(rval);
      }
    }
  // check for a compressed file
  char *realfilename;
  char *command;
  FILE *fout;
  command = (char *)malloc(strlen(filename)+25);
  // check for .Z (unix compress)
  sprintf(command,"zcat %s.Z",filename);
  realfilename = command+5;
  iout << "Command = " << command << "\n" << endi;
  iout << "Filename.Z = " << realfilename << "\n" << endi;
  if (!stat(realfilename,&buf))
        {
        if (!S_ISDIR(buf.st_mode))
                {
                fout = popen(command,mode);
                // on HP-UX, the first character(s) out of pipe may be
                // garbage!  (Argh!)
                int C;
                do
                  {
                  C = fgetc(fout);
                  // iout << "C is " << C << "\n" << endi;
                  if (isalnum(C) || isspace(C))
                        {
                        ungetc(C,fout);
                        C = -1; // outta loop
                        }
                  } while(C != -1);
                free(command);
                return(fout);
                }
        }
  // check for .gz (gzip)
  sprintf(command,"gzip -d -c %s.gz",filename);
  realfilename = command+11;
  iout << "Command = " << command << "\n" << endi;
  iout << "Filename.gz = " << realfilename << "\n" << endi;
  if (!stat(realfilename,&buf))
        {
        if (!S_ISDIR(buf.st_mode))
                {
                fout = popen(command,mode);
                // on HP-UX, the first character(s) out of pipe may be
                // garbage!  (Argh!)
                int C;
                do
                  {
                  C = fgetc(fout);
                  // iout << "C is " << C << "\n" << endi;
                  if (isalnum(C) || isspace(C))
                        {
                        ungetc(C,fout);
                        C = -1; // outta loop
                        }
                  } while(C != -1);
                free(command);
                return(fout);
                }
        }
  free(command);
#endif /* !defined(NOCOMPRESSED) */

  return(NULL);
} /* Fopen() */

NAMD_backup_file()

void NAMD_backup_file	(	const char *	filename,
		const char *	extension
	)

Definition at line 236 of file common.C.

References endi(), iERROR(), iout, and NAMD_file_exists().

Referenced by Controller::adaptTempInit(), colvarproxy_namd::backup_file(), ofstream_namd::open(), open_dcd_write(), Controller::outputExtendedSystem(), Controller::outputFepEnergy(), Controller::outputTiEnergy(), CollectionMaster::receiveDataStream(), and Controller::write_accelMDG_rest_file().

{
  if (NAMD_file_exists(filename)) {
    if ( ! extension ) extension = ".BAK";
    char *backup = new char[strlen(filename)+strlen(extension)+1];
    strcpy(backup, filename);
    strcat(backup, extension);
#if defined(WIN32) && !defined(__CYGWIN__)
    if ( remove(backup) ) if ( errno != ENOENT ) {
      char *sys_err_msg = strerror(errno);
      if ( ! sys_err_msg ) sys_err_msg = "(unknown error)";
      iout << iERROR << "Error on removing file "
        << backup << ": " << sys_err_msg << "\n" << endi;
      fflush(stdout);
    }
#endif
    while ( rename(filename,backup) )
    {
      if ( errno == EINTR ) continue;
      const char *sys_err_msg = strerror(errno);
      if ( ! sys_err_msg ) sys_err_msg = "(unknown error)";
      iout << iERROR << "Error on renaming file " << filename
        << " to " << backup << ": " << sys_err_msg << "\n" << endi;
      fflush(stdout);
      if ( errno == EXDEV ) continue;
      break;
      // char errmsg[256];
      // sprintf(errmsg, "Error on renaming file %s to %s",filename,backup);
      // NAMD_err(errmsg);
    }
    delete [] backup;
  }
}

NAMD_bug()

void NAMD_bug

(

const char *

err_msg

)

Definition at line 196 of file common.C.

References Node::Object().

Referenced by Sequencer::algorithm(), Controller::algorithm(), SynchronousCollectives::allGather(), SynchronousCollectives::allReduce(), SynchronousCollectives::alltoallv(), CollectProxyVectorInstance::append(), CudaComputeNonbonded::assignPatches(), CudaComputeNonbonded::assignPatchesOnPe(), PmePencilXYZ::backwardDone(), LdbCoordinator::barrier(), SynchronousCollectives::barrier(), SynchronousCollectives::broadcast(), HomePatch::buildRattleList_SOA(), HomePatch::buildSpanningTree(), ReductionMgr::buildSpanTree(), ComputeNonbondedUtil::calc_error(), Controller::calcPressure(), ComputePmeMgr::chargeGridReady(), checkSum(), ofstream_namd::close(), Box< Patch, CompAtom >::close(), Controller::compareChecksums(), ComputeCUDAMgr::ComputeCUDAMgr(), ComputePmeCUDAMgr::ComputePmeCUDAMgr(), ComputeTclBC::ComputeTclBC(), CudaPmeTranspose::copyDataDeviceToDevice(), CudaPmeTranspose::copyDataDeviceToHost(), CudaPmeTranspose::copyDataHostToDevice(), WorkDistrib::createAtomLists(), ComputeCUDAMgr::createCudaComputeNonbonded(), ComputePmeCUDAMgr::createDevicesAndAtomFiler(), CsmAckHandler(), CsmHandler(), cudaNAMD_bug(), CudaPmeOneDevice::CudaPmeOneDevice(), CudaPmeRealSpaceCompute::CudaPmeRealSpaceCompute(), MigrateAtomsCombinedMsg::distribute(), ComputeGridForce::doForce(), HomePatch::doGroupSizeCheck(), HomePatch::doGroupSizeCheck_SOA(), ComputePme::doWork(), CudaComputeNonbonded::doWork(), WorkDistrib::enqueueAngles(), WorkDistrib::enqueueAniso(), WorkDistrib::enqueueBonds(), WorkDistrib::enqueueCrossterms(), WorkDistrib::enqueueDihedrals(), WorkDistrib::enqueueExcls(), WorkDistrib::enqueueGromacsPair(), WorkDistrib::enqueueImpropers(), WorkDistrib::enqueueLCPO(), WorkDistrib::enqueueOneFourNbThole(), WorkDistrib::enqueuePme(), WorkDistrib::enqueueSelfA1(), WorkDistrib::enqueueSelfA2(), WorkDistrib::enqueueSelfA3(), WorkDistrib::enqueueSelfB1(), WorkDistrib::enqueueSelfB2(), WorkDistrib::enqueueSelfB3(), WorkDistrib::enqueueThole(), WorkDistrib::enqueueWork(), WorkDistrib::enqueueWorkA1(), WorkDistrib::enqueueWorkA2(), WorkDistrib::enqueueWorkA3(), WorkDistrib::enqueueWorkB1(), WorkDistrib::enqueueWorkB2(), WorkDistrib::enqueueWorkB3(), WorkDistrib::enqueueWorkC(), ScriptTcl::eval(), ComputeMap::extendPtrs(), findRecipEvirPe(), CudaComputeNonbonded::finishReductions(), ofstream_namd::flush(), SimpleBroadcastObject< Tensor >::get(), PmeAtomStorage::getAtomIndex(), getBlockDim(), CudaPmeTranspose::getBuffer(), ComputeCUDAMgr::getComputeCUDAMgr(), ComputeCUDAMgr::getCudaComputeNonbonded(), ComputePmeCUDAMgr::getDevice(), ComputePmeCUDAMgr::getDevicePencilY(), ComputePmeCUDAMgr::getDevicePencilZ(), ParseOptions::getfromptr(), ComputePmeCUDAMgr::getHomePencil(), ComputeLjPmeSerialMgr::getLJparameters(), Communicate::getMessage(), ComputePmeCUDAMgr::getNode(), getPencilDim(), Controller::getTotalPotentialEnergy(), globalAtomIDToSOAID(), GlobalGPUMgr::GlobalGPUMgr(), GridforceFullBaseGrid::grid_index(), FFTCompute::init(), ComputePmeCUDA::initialize(), ComputePatch::initialize(), ComputeHomePatch::initialize(), ComputePme::initialize(), LdbCoordinator::initialize(), ParallelIOMgr::initialize(), ComputePmeMgr::initialize(), ComputePmeMgr::initialize_computes(), IRSet::insert(), ParseOptions::issetfromptr(), ParseOptions::istruefromptr(), CudaComputeNonbonded::launchWork(), LdbCoordinator::LdbCoordinator(), ScriptTcl::load(), NamdState::loadStructure(), PatchMap::makePatches(), WorkDistrib::messageEnqueueWork(), CudaComputeNonbonded::messageEnqueueWork(), WorkDistrib::messageFinishCUDA(), WorkDistrib::messageFinishMIC(), HomePatch::minimize_rattle2(), Sequencer::multigratorPressure(), NAMD_version(), NAMD_write(), Node::Node(), PmeZPencil::node_process_untrans(), PmeYPencil::node_process_untrans(), ofstream_namd::open(), Box< Patch, CompAtom >::open(), CudaComputeNonbonded::openBoxesOnPe(), PatchMap::pack(), PatchMgr::PatchMgr(), CudaComputeNonbonded::patchReady(), PmePencilX::PmePencilX(), PmePencilXY::PmePencilXY(), PmePencilXYZ::PmePencilXYZ(), PmePencilY::PmePencilY(), PmePencilZ::PmePencilZ(), PmeTranspose::PmeTranspose(), ComputePmeMgr::pollChargeGridReady(), ComputePmeMgr::pollForcesReady(), PmePencilXYZMap::populateInitial(), PmePencilXMap::populateInitial(), PmePencilXYMap::populateInitial(), PmePencilMap::populateInitial(), Controller::printEnergies(), Rebalancer::printLoads(), PmePencilXMap::procNum(), PmePencilXYMap::procNum(), ProxyMgr::ProxyMgr(), HomePatch::rattle2(), Sequencer::reassignVelocities(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), ParallelIOMgr::receiveForces(), ParallelIOMgr::receivePositions(), ParallelIOMgr::receiveVelocities(), recursive_bisect_with_curve(), recvAck(), ComputePmeMgr::recvAck(), ComputePmeCUDADevice::recvAtoms(), ComputePmeCUDADevice::recvAtomsFromNeighbor(), recvBcast(), BroadcastMgr::recvBroadcast(), PatchMgr::recvCheckpointAck(), HomePatch::recvCheckpointLoad(), PatchMgr::recvCheckpointReq(), WorkDistrib::recvComputeMapChanges(), ComputeMgr::recvCudaGlobalMasterUpdateResultMsg(), GlobalMasterServer::recvData(), recvData(), ComputePmeCUDAMgr::recvDevices(), recvEvalCommand(), recvEvalResult(), PatchMgr::recvExchangeReq(), ComputePmeCUDADevice::recvForcesFromNeighbor(), ComputePmeMgr::recvGrid(), ComputeQMMgr::recvPartQM(), ComputePmeMgr::recvRecipEvir(), Output::recvReplicaDcdData(), ComputeGlobal::recvResults(), ProxyMgr::recvResults(), ComputePmeMgr::recvUngrid(), NodePmeMgr::recvUngrid(), ReductionSet::ReductionSet(), AtomMapper::registerIDsCompAtomExt(), AtomMapper::registerIDsFullAtom(), registerUserEventsForAllComputeObjs(), Node::reloadGridforceGrid(), ReductionMgr::remoteSubmit(), IRSet::remove(), replica_bcast(), replica_min_double(), RequireReductionShared::RequireReductionShared(), CollectProxyVectorInstance::reset(), CollectionMgr::CollectVectorInstance::reset(), CollectionMaster::CollectVectorInstance::reset(), ComputeGlobal::saveTotalForces(), Sequencer::scalePositionsVelocities(), ComputeNonbondedUtil::select(), PmeZPencil::send_ungrid(), PatchMgr::sendAtoms(), NodePmeMgr::sendDataHelper(), ComputePmeMgr::sendDataPart(), Communicate::sendMessage(), PatchMgr::sendMovePatches(), PatchMgr::sendOneHomePatch(), NodePmeMgr::sendPencilsHelper(), ComputePmeMgr::sendPencilsPart(), CudaPmeTranspose::setDataPtrsYZX(), CudaPmeTranspose::setDataPtrsZXY(), ComputePmeCUDADevice::setPencilProxy(), ComputePmeCUDAMgr::setupPencils(), SimpleBroadcastObject< Tensor >::SimpleBroadcastObject(), Box< Patch, CompAtom >::skip(), CudaComputeNonbonded::skipPatchesOnPe(), CudaPmeKSpaceCompute::solve(), Node::startup(), ComputeMap::storeCompute(), ComputePmeCUDA::storePmeForceMsg(), PmePencilXYZ::submitReductions(), PmePencilZ::submitReductions(), ComputePmeMgr::submitReductions(), SubmitReductionShared::SubmitReductionShared(), Sync::Sync(), SynchronousCollectives::SynchronousCollectives(), TopoManagerWrapper::TopoManagerWrapper(), CudaPmeTranspose::transposeXYZtoYZX(), CudaPmeTranspose::transposeXYZtoZXY(), IRSet::unchecked_insert(), ComputePme::ungridForces(), ComputeMap::unpack(), GridforceGrid::unpack_grid(), CudaComputeNonbonded::unregisterBoxesOnPe(), AtomMapper::unregisterIDsCompAtomExt(), AtomMapper::unregisterIDsFullAtom(), ComputeCUDAMgr::update(), ComputeMgr::updateComputes(), Node::updateGridScale(), WorkDistrib::WorkDistrib(), AtomMapper::~AtomMapper(), and Rebalancer::~Rebalancer().

{
  if ( ! err_msg ) err_msg = "(unknown error)";
  const char *bug_msg = 
    "FATAL ERROR: See http://www.ks.uiuc.edu/Research/namd/bugreport.html";
  CkPrintf("FATAL ERROR: %s\n%s\n",err_msg, bug_msg);
  fflush(stdout);
  char repstr[24] = "";
  if (CmiNumPartitions() > 1 ||
      (Node::Object()->simParameters != 0 &&
       Node::Object()->simParameters->CUDASOAintegrateMode)) {
    sprintf(repstr,"REPLICA %d ", CmiMyPartition());
    // CkAbort ensures that all replicas die
    CkAbort("%sFATAL ERROR: %s\n%s\n", repstr, err_msg, bug_msg);
  }
  CkError("%sFATAL ERROR: %s\n%s\n", repstr, err_msg, bug_msg);
#if CHARM_VERSION < 61000
  CkExit();
#else
  CkExit(2);
#endif
}

NAMD_close()

void NAMD_close	(	int	fd,
		const char *	fname
	)

Definition at line 316 of file common.C.

                                           {
#if defined(WIN32) && !defined(__CYGWIN__)
  while ( _close(fd) ) {
#else
  while ( close(fd) ) {
#endif
    if ( errno != EINTR ) {
      char errmsg[1024];
      sprintf(errmsg, "Error on closing file %s", fname);
      NAMD_err(errmsg);
    }
  }
}

NAMD_die()

void NAMD_die

(

const char *

err_msg

)

Definition at line 148 of file common.C.

References Node::Object().

Referenced by Controller::adaptTempInit(), ConfigList::add_element(), ComputeMsmMgr::addPotential(), after_backend_init(), Sequencer::algorithm(), Controller::algorithm(), CollectiveDeviceBuffer< T >::allocate_no_check(), AnisoElem::AnisoElem(), msm::PatchData::anterpolation(), msm::PatchData::anterpolationC1Hermite(), Parameters::assign_angle_index(), Parameters::assign_bond_index(), Parameters::assign_crossterm_index(), Parameters::assign_dihedral_index(), Parameters::assign_improper_index(), Parameters::assign_vdw_index(), WorkDistrib::assignNodeToPatch(), Molecule::build_go_arrays(), Molecule::build_go_params(), Molecule::build_go_sigmas(), Molecule::build_go_sigmas2(), Molecule::build_gridforce_params(), buildBondData(), HomePatch::buildRattleList(), ReductionMgr::buildSpanTree(), ParallelIOMgr::calcAtomsInEachPatch(), ComputeQMMgr::calcMOPAC(), ComputeQMMgr::calcORCA(), GlobalMasterTest::calculate(), GlobalMasterTcl::calculate(), GlobalMaster::calculate(), ComputeQMMgr::calcUSR(), Calloc(), GlobalMaster::check(), GroupRestraintParam::CheckParam(), ComputeMsmMgr::compute(), PmeRealSpace::compute_forces(), LjPmeRealSpace::compute_scaledForces(), OneFourNbTholeElem::computeForce(), AngleElem::computeForce(), LjPmeCompute::computeLJpotential(), ComputeTclBC::ComputeTclBC(), ConfigList::ConfigList(), NamdState::configListInit(), ConfigList::ConfigListNode::ConfigListNode(), Sequencer::correctMomentum(), Controller::correctMomentum(), WorkDistrib::createAtomLists(), cuda_errcheck(), cuda_getargs(), CudaComputeNonbonded::CudaComputeNonbonded(), cudaDie(), CudaGlobalMaster::CUDAGM_NS::CudaGlobalMasterClient::CudaGlobalMasterClient(), CudaGlobalMasterServer::CudaGlobalMasterServer(), curandDie(), ComputeMsmMgr::d_stencil_1d(), Molecule::delete_qm_bonded(), ComputeGridForce::doForce(), ComputeNonbondedSelf::doForce(), HomePatch::doMarginCheck(), HomePatch::doMarginCheck_SOA(), Parameters::done_reading_files(), ComputeFullDirect::doWork(), ComputeTclBC::doWork(), ARestraint::EarlyExit(), Node::earlyExit(), GlobalMasterMisc::easy_calc(), msm::Array< msm::PatchDiagram >::elem(), msm::GridFixed< T, N >::elem(), msm::Grid< Vtype >::elem(), colvarproxy_namd::error(), ScriptTcl::eval(), PmeZPencil::fft_init(), PmeYPencil::fft_init(), PmeXPencil::fft_init(), LjPmeRealSpace::fill_charges(), PmeRealSpace::fill_charges(), Ambertoppar::get(), Molecule::get_atom_from_index_in_residue(), Molecule::get_atom_from_name(), Molecule::get_atomtype(), Parameters::get_dihedral_params(), Molecule::get_fep_bonded_type(), Parameters::get_improper_params(), Molecule::get_residue_size(), Parameters::get_vdw_params(), IndexFile::getAllElements(), ComputeLjPmeSerialMgr::getLJparameters(), OneFourNbTholeElem::getMoleculePointers(), AngleElem::getMoleculePointers(), ImproperElem::getMoleculePointers(), CrosstermElem::getMoleculePointers(), DihedralElem::getMoleculePointers(), TholeElem::getMoleculePointers(), AnisoElem::getMoleculePointers(), ExclElem::getMoleculePointers(), BondElem::getMoleculePointers(), GromacsPairElem::getMoleculePointers(), IndexFile::getNElements(), OneFourNbTholeElem::getTupleInfo(), TholeElem::getTupleInfo(), AnisoElem::getTupleInfo(), GlobalMasterIMD::GlobalMasterIMD(), GlobalMasterSymmetry::GlobalMasterSymmetry(), LjPmeMgr::gridCalculation(), GromacsTopFile::GromacsTopFile(), IndexFile::IndexFile(), BackEnd::init(), LjPmeCompute::initialize(), LjPmeMgr::initialize(), LdbCoordinator::initialize(), DeviceCUDA::initialize(), GridforceFullMainGrid::initialize(), GridforceFullSubGrid::initialize(), GridforceLiteGrid::initialize(), ComputeMsmMgr::initialize(), ComputePmeMgr::initialize(), SimParameters::initialize_config_data(), msm::PatchData::interpolation(), msm::PatchData::interpolationC1Hermite(), LjPmeKSpace::LjPmeKSpace(), ScriptTcl::load(), NamdState::loadStructure(), ludcmp(), main::main(), Malloc(), Node::mallocTest(), WorkDistrib::mapComputes(), HomePatch::minimize_rattle2(), Molecule::Molecule(), HomePatch::mollyAverage(), HomePatch::mollyMollify(), NAMD_new_handler(), NAMD_read_int(), NAMD_read_line(), NAMD_seek(), NAMD_write(), ComputeMsmMgr::ndsplitting(), OneFourNbTholeElem::OneFourNbTholeElem(), IndexFile::open(), LjPmeMgr::optimizeFFT(), Node::outputPatchComputeMaps(), MGridforceParamsList::pack_data(), WorkDistrib::patchMapInit(), PDB::PDB(), PDBUnknown::PDBUnknown(), Ambertoppar::preadln(), Molecule::prepare_qm(), ProblemParsing(), MsmBlockProxyMsg::put(), MsmC1HermiteBlockProxyMsg::put(), HomePatch::rattle1old(), HomePatch::rattle2(), Molecule::read_alch_unpert_angles(), Molecule::read_alch_unpert_bonds(), Molecule::read_alch_unpert_dihedrals(), read_binary_file(), Parameters::read_charmm_parameter_file(), Parameters::read_ener_table(), Parameters::read_energy_type(), Parameters::read_energy_type_bothcubspline(), Parameters::read_energy_type_cubspline(), Molecule::read_go_file(), Parameters::read_parameter_file(), Parameters::read_parm(), SimParameters::readExtendedSystem(), AmberParm7Reader::readparm(), GridforceFullBaseGrid::readSubgridHierarchy(), Realloc(), CollectiveDeviceBuffer< T >::reallocate_no_check(), RecBisection::RecBisection(), Molecule::receive_GoMolecule(), Parameters::receive_Parameters(), CollectionMaster::receiveDataStream(), ParallelIOMgr::recvAtomsCntPerPatch(), Controller::recvCheckpointReq(), HomePatch::recvCheckpointReq(), ComputeMgr::recvComputeDPMEData(), ComputeMgr::recvComputeDPMEResults(), ComputeMgr::recvComputeEwaldData(), ComputeMgr::recvComputeEwaldResults(), ComputeMgr::recvComputeGlobalData(), ComputeMgr::recvComputeGlobalResults(), ComputeMsmSerialMgr::recvCoord(), ComputeExtMgr::recvCoord(), ComputeLjPmeSerialMgr::recvCoord(), ComputeFmmSerialMgr::recvCoord(), ComputeMgr::recvCudaGlobalMasterCreateMsg(), ComputeMgr::recvCudaGlobalMasterRemoveMsg(), ComputeMgr::recvCudaGlobalMasterUpdateMsg(), SynchronousCollectives::recvIndexData(), ComputeQMMgr::recvPartQM(), ComputeQMMgr::recvPntChrg(), Output::recvReplicaDcdData(), Node::reloadCharges(), Node::reloadGridforceGrid(), ReductionMgr::remoteRegister(), ReductionMgr::remoteUnregister(), ReductionSet::removeData(), Sequencer::rescaleaccelMD(), Controller::rescaleaccelMD(), ScriptTcl::run(), ComputeMsm::saveResults(), SimParameters::scriptSet(), ComputeNonbondedUtil::select(), GlobalMasterIMD::send_box(), GlobalMasterIMD::send_energies(), GlobalMasterIMD::send_fcoords(), GlobalMasterIMD::send_forces(), Molecule::send_GoMolecule(), Parameters::send_Parameters(), GlobalMasterIMD::send_time(), GlobalMasterIMD::send_velocities(), ComputeMgr::sendComputeDPMEData(), ComputeMgr::sendComputeEwaldData(), StringList::set(), GroupRestraintParam::SetGroup1AtomFileIndices(), GroupRestraintParam::SetGroup1AtomListIndices(), GroupRestraintParam::SetGroup1RefPosition(), GroupRestraintParam::SetGroup2AtomFileIndices(), GroupRestraintParam::SetGroup2AtomListIndices(), GroupRestraintParam::SetGroupName(), msm::Array< msm::PatchDiagram >::setmax(), GroupRestraintParam::SetResCenter(), GroupRestraintParam::SetResDirection(), ComputeMsmMgr::setup_hgrid_1d(), ComputeMsmMgr::setup_periodic_blocksize(), SimParameters::setupIDWS(), PatchMap::sizeGrid(), ComputeMsmMgr::splitting(), ComputeMsmMgr::stencil_1d(), NamdCentLB::Strategy(), StringList::StringList(), ScriptTcl::tclmain(), TestArray_write(), TholeElem::TholeElem(), ComputeLonepairsCUDA::updateAtoms(), Node::updateGridScale(), ReductionMgr::willRequire(), and ReductionMgr::willSubmit().

{
  if ( ! err_msg ) err_msg = "(unknown error)";
  CkPrintf("FATAL ERROR: %s\n", err_msg);
  fflush(stdout);
  char repstr[24] = "";
  if (CmiNumPartitions() > 1 || 
      (Node::Object()->simParameters != 0 &&
       Node::Object()->simParameters->CUDASOAintegrateMode)) {
    sprintf(repstr,"REPLICA %d ", CmiMyPartition());
    // CkAbort ensures that all replicas die
    CkAbort("%sFATAL ERROR: %s\n", repstr, err_msg);
  }
  CkError("%sFATAL ERROR: %s\n", repstr, err_msg);
#if CHARM_VERSION < 61000
  CkExit();
#else
  CkExit(1);
#endif
}

NAMD_err()

void NAMD_err

(

const char *

err_msg

)

Definition at line 171 of file common.C.

References Node::Object().

Referenced by after_backend_init(), ComputeQMMgr::calcMOPAC(), ComputeQMMgr::calcORCA(), ComputeQMMgr::calcUSR(), close_dcd_write(), colvarproxy_namd::error(), NAMD_close(), NAMD_open(), NAMD_open_text(), NAMD_seek(), NAMD_write(), Controller::outputExtendedSystem(), PDB::PDB(), AmberParm7Reader::read_amber_parm_stage1(), ComputeQMMgr::recvPartQM(), Output::recvReplicaDcdData(), and PDB::write().

{
  if ( ! err_msg ) err_msg = "(unknown error)";
  const char *sys_err_msg = strerror(errno);
  if ( ! sys_err_msg ) sys_err_msg = "(unknown error)";
  CkPrintf("FATAL ERROR: %s: %s\n", err_msg, sys_err_msg);
  fflush(stdout);
  char repstr[24] = "";
  if (CmiNumPartitions() > 1 ||
      (Node::Object()->simParameters != 0 &&
       Node::Object()->simParameters->CUDASOAintegrateMode)) {
    sprintf(repstr,"REPLICA %d ", CmiMyPartition());
    // CkAbort ensures that all replicas die
    CkAbort("%sFATAL ERROR: %s: %s\n", repstr, err_msg, sys_err_msg);
  }
  CkError("%sFATAL ERROR: %s: %s\n", repstr, err_msg, sys_err_msg);
#if CHARM_VERSION < 61000
  CkExit();
#else
  CkExit(1);
#endif
}

NAMD_file_exists()

int NAMD_file_exists

(

const char *

filename

)

Definition at line 220 of file common.C.

References endi(), iERROR(), and iout.

Referenced by NAMD_backup_file().

                                           {
  int rval;
  do {
    rval = access(filename, F_OK);
  } while ( rval != 0 && errno == EINTR );
  if ( rval != 0 && errno != ENOENT ) {
    const char *sys_err_msg = strerror(errno);
    if ( ! sys_err_msg ) sys_err_msg = "(unknown error)";
    iout << iERROR << "Error on checking file "
      << filename << ": " << sys_err_msg << "\n" << endi;
    fflush(stdout);
  }
  return ! rval;
}

NAMD_gcd()

int NAMD_gcd	(	int	a,
		int	b
	)

Definition at line 103 of file common.C.

References NAMD_gcd().

Referenced by Sequencer::integrate(), Sequencer::integrate_SOA(), and NAMD_gcd().

{
   if(a == 0 || b == 0) return 0;
   else if(a == b) return a;
   else if(a > b) return NAMD_gcd(a-b,b);
   return NAMD_gcd(a, b-a);
}

NAMD_open_text()

int NAMD_open_text	(	const char *	fname,
		int	append
	)

Definition at line 271 of file common.C.

References NAMD_err().

Referenced by ofstream_namd::open().

                                                  {
  int fd;

  //  open the file and die if the open fails
#if defined(WIN32) && !defined(__CYGWIN__)
  while ( (fd = _open(fname, O_WRONLY|(append?O_APPEND:O_EXCL)|O_CREAT|O_TEXT,_S_IREAD|_S_IWRITE)) < 0) {
#else
#ifdef NAMD_NO_O_EXCL
  while ( (fd = open(fname, O_WRONLY|(append?O_APPEND:O_TRUNC)|O_CREAT,
#else
  while ( (fd = open(fname, O_WRONLY|(append?O_APPEND:O_EXCL)|O_CREAT,
#endif
                           S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) {
#endif
    if ( errno != EINTR ) {
      char errmsg[1024];
      sprintf(errmsg, "Unable to open text file %s", fname);
      NAMD_err(errmsg);
    }
  }

  return fd;
}

NAMD_quit()

void NAMD_quit

(

const char *

err_msg

)

Definition at line 126 of file common.C.

References Node::Object().

Referenced by GlobalMasterIMD::get_vmd_forces(), and Controller::printTiming().

{
  if ( ! err_msg ) err_msg = "(unknown error)";
  CkPrintf("EXITING: %s\n", err_msg);
  fflush(stdout);
  char repstr[24] = "";
  if (CmiNumPartitions() > 1
      || Node::Object()->simParameters->CUDASOAintegrateMode) {
    sprintf(repstr,"REPLICA %d ", CmiMyPartition());
    // CkAbort ensures that all replicas die
    CkAbort("%sEXITING: %s\n", repstr, err_msg);
  }
  CkError("%sEXITING: %s\n", repstr, err_msg);
#if CHARM_VERSION < 61000
  CkExit();
#else
  CkExit(0);
#endif
}

NAMD_stringdup()

char* NAMD_stringdup

(

const char *

s

)

Definition at line 112 of file common.C.

                                    {
  char *rs;

  if(!s)
    return NULL;

  rs = new char[strlen(s) + 1];
  strcpy(rs,s);

  return rs;
}

NAMD_version()

void NAMD_version	(	int *	major,
		int *	minor,
		int *	patchLevel,
		int *	releaseType
	)

Definition at line 57 of file common.C.

References NAMD_ALPHA_RELEASE, NAMD_BETA_RELEASE, NAMD_bug(), NAMD_FINAL_RELEASE, NAMD_UNKNOWN_RELEASE, and NAMD_version_string().

{
  int NAMD_major = 0;
  int NAMD_minor = 0;
  int NAMD_patchLevel = 0;
  int NAMD_releaseType = NAMD_UNKNOWN_RELEASE;

  // have to parse the version string to determine numbers
  const char *vstr = NAMD_version_string();
  char dot[4] = "";  // expect to read "."
  char release[8] = "";  // expect to read "" or "."
                         // or "alpha" or "beta" or "final" or "release"
  char extra[4] = "";  // bad version string if we read an extra character
  int n = sscanf(vstr, "%d%3[^0-9]%d%7[^0-9]%d%c",
      &NAMD_major, dot, &NAMD_minor, release, &NAMD_patchLevel, extra);
  if (n < 3 || n > 5) {
    NAMD_bug("Unable to parse NAMD_VERSION from Makefile");
  }
  if (n >= 4) {
    if (strcmp(release, "a") == 0 || strcmp(release, "alpha") == 0) {
      NAMD_releaseType = NAMD_ALPHA_RELEASE;
    }
    else if (strcmp(release, "b") == 0 || strcmp(release, "beta") == 0) {
      NAMD_releaseType = NAMD_BETA_RELEASE;
    }
    else if (strcmp(release, ".") == 0 ||
             strcmp(release, "final") == 0 ||
             strcmp(release, "release") == 0 ||
             strcmp(release, "patch") == 0) {
      NAMD_releaseType = NAMD_FINAL_RELEASE;
    }
    else {
      NAMD_bug("Unable to parse NAMD_VERSION from Makefile");
    }
  }
  else {
    NAMD_releaseType = NAMD_FINAL_RELEASE;
  }
  // now return values to caller
  if (major != NULL) *major = NAMD_major;
  if (minor != NULL) *minor = NAMD_minor;
  if (patchLevel != NULL) *patchLevel = NAMD_patchLevel;
  if (releaseType != NULL) *releaseType = NAMD_releaseType;
}

NAMD_version_string()

const char* NAMD_version_string

(

void

)

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 52 of file common.C.

Referenced by NAMD_version().

                                  {
  return NAMD_VERSION;  // macro defined in toplevel Makefile
}

NAMD_write()

void NAMD_write	(	int	fd,
		const char *	buf,
		size_t	count,
		const char *	fname
	)

Definition at line 296 of file common.C.

                                                                          {
  while ( count ) {
#if defined(WIN32) && !defined(__CYGWIN__)
    long retval = _write(fd,buf,count);
#else
    ssize_t retval = write(fd,buf,count);
#endif
    if ( retval < 0 && errno == EINTR ) retval = 0;
    if ( retval < 0 ) {
      char errmsg[1024];
      sprintf(errmsg, "Error on writing to file %s", fname);
      NAMD_err(errmsg);
    }
    if ( retval > count ) NAMD_bug("extra bytes written in NAMD_write()");
    buf += retval;
    count -= retval;
  }
}