Output Class Reference

#include <Output.h>

Public Member Functions
	Output ()
	~Output ()
void	energy (int, BigReal *)
void	coordinate (int timestep, int n, Vector *coor, FloatVector *fcoor, Lattice &lattice)
	Produce appropriate coordinate output for the current timestep. More...
void	velocity (int timestep, int n, Vector *vel, FloatVector *fvel)
	Produce appropriate velocity for the current timestep. More...
void	force (int timestep, int n, Vector *frc, FloatVector *ffrc)
	Produce appropriate force for the current timestep. More...
void	replicaDcdOff ()
void	setReplicaDcdIndex (int index)
void	replicaDcdInit (int index, const char *filename)
void	replicaDcdSelectInit (int index, const char *tag, const char *filename)
void	recvReplicaDcdInit (ReplicaDcdInitMsg *msg)
void	recvReplicaDcdData (ReplicaDcdDataMsg *msg)

Static Public Member Functions
static std::pair< int, int >	coordinateNeeded (int timestep)
	Check if the step requires to output the coordinates. More...
static int	velocityNeeded (int timestep)
	Check if the step requires to output the velocities. More...
static int	forceNeeded (int timestep)
	Check if the step requires to output the forces. More...

Friends
class	SimParameters

Detailed Description

Definition at line 35 of file Output.h.

Constructor & Destructor Documentation

Output()

Output::Output

(

)

Definition at line 171 of file Output.C.

: replicaDcdActive(0) { }

~Output()

Output::~Output

(

)

Definition at line 181 of file Output.C.

{ }

Member Function Documentation

coordinate()

void Output::coordinate	(	int	timestep,
		int	n,
		Vector *	coor,
		FloatVector *	fcoor,
		Lattice &	lattice
	)

Produce appropriate coordinate output for the current timestep.

Parameters

timestep	Timestep coordinates were accumulated for
n	The number of coordinates accumulated
coor	Array of Vectors containing the coordinates in double precision. If the second bit of the first bitmask of coordinateNeeded is 1, then this parameter shouldn't be nullptr or NULL.
fcoor	Array of Vectors containing the coordinates in single precision. If the first bit of the first bitmask of coordinateNeeded is 1, then this parameter shouldn't be nullptr or NULL.
lattice	The PBC box for wrapping the output coordinates

Definition at line 334 of file Output.C.

References Lattice::a(), Lattice::b(), Lattice::c(), Molecule::dcdSelectionParams, END_OF_RUN, endi(), EVAL_MEASURE, FILE_OUTPUT, dcd_params::frequency, IMDOutput::gather_box(), IMDOutput::gather_coordinates(), Molecule::get_dcd_selection_index_from_atom_id(), Molecule::get_dcd_selection_size(), Node::getScript(), Node::imd, IMDv2, IMDv3, iout, ScriptTcl::measure(), Node::molecule, Node::Object(), Node::simParameters, simParams, dcd_params::size, dcd_params::tag, wrap_coor(), wrap_coor_dcd_selection(), Vector::x, Vector::y, and Vector::z.

Referenced by CollectionMaster::disposePositions().

{
  SimParameters *simParams = Node::Object()->simParameters;
  Molecule *molecule = Node::Object()->molecule;
  double coor_wrapped = 0;
  float fcoor_wrapped = 0;

  if ( timestep >= 0 ) {

    //  Output a DCD trajectory 
    if ( simParams->dcdFrequency &&
       ((timestep % simParams->dcdFrequency) == 0) )
    {
      wrap_coor(fcoor,lattice,&fcoor_wrapped);
      output_dcdfile(timestep, n, fcoor, 
                     simParams->dcdUnitCell ? &lattice : NULL, 0);
    }

    //  Output any DCD selection trajectories that this timestep mods
    if ( simParams->dcdSelectionOn)
    {
      bool needCleanup = false;

      for(int index=0; index<16;++index)
        {
          int frequency=molecule->dcdSelectionParams[index].frequency;
          uint16 tag=molecule->dcdSelectionParams[index].tag;
          int size=molecule->dcdSelectionParams[index].size;
          if(frequency>0 && (timestep % frequency) == 0)
            {
              FloatVector *dcdSelectionFcoor = fcoor;
              int dcdSelectionNpoints = n;
              if(dcdSelectionNpoints != molecule->get_dcd_selection_size(index))
                {
                  // on intervals when some other output is also happening, we have
                  // to filter out a copy of the selection from the full
                  // collected output then wrap and output accordingly
                  dcdSelectionNpoints = size;
                  dcdSelectionFcoor =  new FloatVector[dcdSelectionNpoints];
                  needCleanup = true;
                  for(int i=0; i<n ;i++)
                    {
                      int offset = molecule->get_dcd_selection_index_from_atom_id(index, i);
                      if(offset >= 0)
                        dcdSelectionFcoor[offset] = fcoor[i];
                    }
                }
              else
                {
                  dcdSelectionFcoor = fcoor;
                }
              wrap_coor_dcd_selection(dcdSelectionFcoor, lattice, &fcoor_wrapped, index);
              output_dcdfile(timestep, dcdSelectionNpoints, dcdSelectionFcoor,
                             simParams->dcdUnitCell ? &lattice : NULL, tag);
              if(needCleanup)
                delete [] dcdSelectionFcoor;
            }

        }
    }

    //  Output a restart file
    if ( simParams->restartFrequency &&
       ((timestep % simParams->restartFrequency) == 0) )
    {
      iout << "WRITING COORDINATES TO RESTART FILE AT STEP "
                                << timestep << "\n" << endi;
      wrap_coor(coor,lattice,&coor_wrapped);
      output_restart_coordinates(coor, n, timestep);
      iout << "FINISHED WRITING RESTART COORDINATES\n" <<endi;
      fflush(stdout);
    }

    //  Interactive MD
    if ( simParams->IMDon &&
       ( ((timestep % simParams->IMDfreq) == 0) ||
         (timestep == simParams->firstTimestep) ) )
    {

    if ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.box_switch == 1))
    {
      IMDOutput *imd = NULL;
#ifdef NODEGROUP_FORCE_REGISTER
      if (simParams->CUDASOAintegrate) {
        CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
        imd = cpdata.ckLocalBranch()->imd;
      }
      else
#endif
      {
        imd = Node::Object()->imd;
      }

      IMDBox box = {(float)lattice.a().x, (float)lattice.a().y, (float)lattice.a().z,
                    (float)lattice.b().x, (float)lattice.b().y, (float)lattice.b().z,
                    (float)lattice.c().x, (float)lattice.c().y, (float)lattice.c().z};

      if (imd != NULL) imd->gather_box(timestep, &box);
    }

    if ((simParams->IMDversion == IMDversion_t::IMDv2) || ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.fcoords_switch == 1)))
    {
      IMDOutput *imd = NULL;
#ifdef NODEGROUP_FORCE_REGISTER
      if (simParams->CUDASOAintegrate) {
        CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
        imd = cpdata.ckLocalBranch()->imd;
      }
      else
#endif
      {
        imd = Node::Object()->imd;
      }
      if ((simParams->IMDversion == IMDversion_t::IMDv2) || ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.wrap_switch == 1)))
        wrap_coor(fcoor,lattice,&fcoor_wrapped);
      if (imd != NULL) imd->gather_coordinates(timestep, n, fcoor);
    }
    
    }

  }

  if (timestep == EVAL_MEASURE)
  {
#ifdef NAMD_TCL
    wrap_coor(coor,lattice,&coor_wrapped);
    Node::Object()->getScript()->measure(coor);
#endif
  }

  //  Output final coordinates
  if (timestep == FILE_OUTPUT || timestep == END_OF_RUN)
  {
    int realstep = ( timestep == FILE_OUTPUT ?
          simParams->firstTimestep : simParams->N );
    iout << "WRITING COORDINATES TO OUTPUT FILE AT STEP "
                                << realstep << "\n" << endi;
    fflush(stdout);
    wrap_coor(coor,lattice,&coor_wrapped);
    output_final_coordinates(coor, n, realstep);
  }

  //  Close trajectory files
  if (timestep == END_OF_RUN)
  {
    if (simParams->dcdFrequency) output_dcdfile(END_OF_RUN,0,0,
                                                simParams->dcdUnitCell
                                                ? &lattice : NULL, 0);
    if ( simParams->dcdSelectionOn)
    {
      for(int dcdSelectionIndex=0; dcdSelectionIndex<16;++dcdSelectionIndex)
        {
          int dcdSelectionFrequency = molecule->dcdSelectionParams[dcdSelectionIndex].frequency;
          int dcdSelectionTag = molecule->dcdSelectionParams[dcdSelectionIndex].tag;
          if(dcdSelectionFrequency)
            output_dcdfile(END_OF_RUN,0,0,
                           simParams->dcdUnitCell
                           ? &lattice : NULL, dcdSelectionTag);
        }
    }
  }
  
}

coordinateNeeded()

std::pair< int, int > Output::coordinateNeeded ( int  timestep )

static

Check if the step requires to output the coordinates.

Parameters

timestep

The current step number

Returns

A pair of bitmasks. The first bitmask indicates whether the step requires to output the velocities. If the first returned bitmask is 0, then the coordinates are not required for output. If its first bit is 1, then the single-precision coordinates are required. If its second bit is 1, then the double-precision coordinates are required. If both the first and the second bit are 1, then both precisions are required. XXX TODO: Document the second bitmask (also known as dcdSelectionTag)

Definition at line 185 of file Output.C.

References Molecule::dcdSelectionParams, END_OF_RUN, EVAL_MEASURE, FILE_OUTPUT, dcd_params::frequency, IMDv2, IMDv3, Node::molecule, Node::Object(), Node::simParameters, simParams, and dcd_params::tag.

Referenced by Controller::enqueueCollections(), Sequencer::submitCollections(), and Sequencer::submitCollections_SOA().

{
  SimParameters *simParams = Node::Object()->simParameters;

  if(simParams->benchTimestep) return std::make_pair(0,0);

  int positionsNeeded = 0;
  uint16 dcdSelectionTag = 0;
  if ( timestep >= 0 ) {

    //  Output a DCD trajectory
    if ( simParams->dcdFrequency &&
       ((timestep % simParams->dcdFrequency) == 0) )
    { positionsNeeded |= 1; }

    //  Output a DCD Selection trajectory

    if (simParams->dcdSelectionOn)
      {
        Molecule *mol = Node::Object()->molecule;
        int tagCount=0;
        for(int index=0; index<16;++index)
          {
            int frequency=mol->dcdSelectionParams[index].frequency;
            uint16 tag=mol->dcdSelectionParams[index].tag;
            if(frequency && (timestep % frequency) == 0)
              { 
                if(++tagCount>1)
                  positionsNeeded |=1; //multi selection means all positions
                positionsNeeded |= 4; dcdSelectionTag = tag;
              }
          }
      }
    //  Output a restart file
    if ( simParams->restartFrequency &&
       ((timestep % simParams->restartFrequency) == 0) )
    { positionsNeeded |= 2; }

    //  Iteractive MD
    if ( simParams->IMDon &&
       ( ((timestep % simParams->IMDfreq) == 0) ||
         (timestep == simParams->firstTimestep) ) &&
         ((simParams->IMDversion == IMDversion_t::IMDv2) || ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.fcoords_switch == 1))) )
      { positionsNeeded |= 1; }

  }

  //  Output final coordinates
  if (timestep == FILE_OUTPUT || timestep == END_OF_RUN ||
                                        timestep == EVAL_MEASURE)
  {
    positionsNeeded |= 2;
  }
  return std::make_pair(positionsNeeded,dcdSelectionTag);
}

energy()

void Output::energy	(	int	,
		BigReal *
	)

force()

void Output::force	(	int	timestep,
		int	n,
		Vector *	frc,
		FloatVector *	ffrc
	)

Produce appropriate force for the current timestep.

This function receives the forces accumulated for a given timestep from the Collect object and calls the appropriate output functions. ALL routines used to output force information should be called from here.

Parameters

timestep	Timestep forces were accumulated for
n	The number of forces accumulated
frc	Array of Vectors containing the forces in double precision. If the second bit of forceNeeded is 1, then this parameter shouldn't be nullptr or NULL.
ffrc	Array of Vectors containing the forces in single precision. If the first bit of forceNeeded is 1, then this parameter shouldn't be nullptr or NULL.

Definition at line 646 of file Output.C.

References endi(), FORCE_OUTPUT, IMDOutput::gather_forces(), Node::imd, IMDv2, IMDv3, iout, Node::Object(), Node::simParameters, and simParams.

Referenced by CollectionMaster::disposeForces().

{
  SimParameters *simParams = Node::Object()->simParameters;

  if ( timestep >= 0 ) {

    //  Output force DCD trajectory
    if ( simParams->forceDcdFrequency &&
       ((timestep % simParams->forceDcdFrequency) == 0) )
    {
      output_forcedcdfile(timestep, n, ffrc);
    }

    //  Interactive MD
    if ( simParams->IMDon &&
       ( ((timestep % simParams->IMDfreq) == 0) ||
         (timestep == simParams->firstTimestep) ) &&
         ((simParams->IMDversion == IMDversion_t::IMDv2) || ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.forces_switch == 1))) )
    {
      IMDOutput *imd = NULL;
#ifdef NODEGROUP_FORCE_REGISTER
      if (simParams->CUDASOAintegrate) {
        CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
        imd = cpdata.ckLocalBranch()->imd;
      }
      else
#endif
      {
        imd = Node::Object()->imd;
      }
      if (imd != NULL) imd->gather_forces(timestep, n, ffrc);
    }

  }

  //  Output forces
  if (timestep == FORCE_OUTPUT)
  {
    int realstep = simParams->firstTimestep;
    iout << "WRITING FORCES TO OUTPUT FILE AT STEP "
                                << realstep << "\n" << endi;
    fflush(stdout);
    output_forces(realstep, n, frc);
  }

  //  Trajectory file closed by velocity() above

}

forceNeeded()

int Output::forceNeeded ( int  timestep )

static

Check if the step requires to output the forces.

Parameters

timestep

The current step number

Returns

A bitmask indicates whether the step requires to output the forces. If the return value is 0, then forces are not required for output. If the first bit of the return value is 1, then the single-precision forces is required. If the second bit is 1, then the double- precision forces is required. If both the first and the second bit are 1, then both precisions are required.

Definition at line 612 of file Output.C.

References FORCE_OUTPUT, IMDv2, IMDv3, Node::Object(), Node::simParameters, and simParams.

Referenced by Controller::enqueueCollections(), Sequencer::submitCollections(), and Sequencer::submitCollections_SOA().

{
  SimParameters *simParams = Node::Object()->simParameters;

  if(simParams->benchTimestep) return 0;

  int forcesNeeded = 0;

  if ( timestep >= 0 ) {

    //  Output a force DCD trajectory
    if ( simParams->forceDcdFrequency &&
       ((timestep % simParams->forceDcdFrequency) == 0) )
      { forcesNeeded |= 1; }

    //  Iteractive MD
    if ( simParams->IMDon &&
       ( ((timestep % simParams->IMDfreq) == 0) ||
         (timestep == simParams->firstTimestep) ) &&
         ((simParams->IMDversion == IMDversion_t::IMDv2) || ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.forces_switch == 1))) )
      { forcesNeeded |= 1; }

  }

  //  Output forces
  if (timestep == FORCE_OUTPUT)
  {
    forcesNeeded |= 2;
  }

  return forcesNeeded;
}

recvReplicaDcdData()

void Output::recvReplicaDcdData

(

ReplicaDcdDataMsg *

msg

)

Definition at line 925 of file Output.C.

References ReplicaDcdDataMsg::data, DCD_FILEEXISTS, ReplicaDcdDataMsg::dcdIndex, ReplicaDcdDataMsg::dcdSelectIndex, ReplicaDcdDataMsg::DELTA, endi(), iout, NAMD_bug(), NAMD_die(), NAMD_err(), namdMyNode, ReplicaDcdDataMsg::NFILE, ReplicaDcdDataMsg::NPRIV, ReplicaDcdDataMsg::NSAVC, ReplicaDcdDataMsg::NSTEP, ReplicaDcdDataMsg::numAtoms, open_dcd_write(), sendReplicaDcdAck(), ReplicaDcdDataMsg::srcPart, ReplicaDcdDataMsg::unitcell, ReplicaDcdDataMsg::with_unitcell, write_dcdheader(), and write_dcdstep().

Referenced by recvReplicaDcdData().

                                                      {
  Molecule *molecule = namdMyNode->molecule;
  if ( msg->dcdSelectIndex>=16 && ! replicaDcdFiles.count(msg->dcdIndex) ||
       ( ! replicaDcdFiles.count(msg->dcdIndex) )) {
    char err_msg[257];
    sprintf(err_msg, "Unknown replicaDcdFile identifier %d\n", msg->dcdIndex);
    NAMD_die(err_msg);
  }
  replicaDcdFile &f = (msg->dcdSelectIndex<16) ? replicaDcdSelectFiles[std::make_pair(msg->dcdIndex,msg->dcdSelectIndex)]: replicaDcdFiles[msg->dcdIndex];

  if ( ! f.fileid ) {
    //  Open the DCD file
    iout << "OPENING REPLICA DCD FILE " << msg->dcdIndex << " " << f.filename.c_str() << "\n" << endi;

    f.fileid=open_dcd_write(f.filename.c_str());

    if (f.fileid == DCD_FILEEXISTS) {
      char err_msg[257];
      sprintf(err_msg, "DCD file %s already exists!!", f.filename.c_str());
      NAMD_err(err_msg);
    } else if (f.fileid < 0) {
      char err_msg[257];
      if(msg->dcdSelectIndex<16)
        sprintf(err_msg, "Couldn't open DCD Index %d Select Index %d file %s", msg->dcdIndex, msg->dcdSelectIndex, f.filename.c_str());
      else
        sprintf(err_msg, "Couldn't open DCD Index %d file %s", msg->dcdIndex, f.filename.c_str());
      NAMD_err(err_msg);
    } else if (! f.fileid) {
      NAMD_bug("Output::recvReplicaDcdData open_dcd_write returned fileid of zero");
    }

    //  Write out the header
    int ret_code = write_dcdheader(f.fileid, f.filename.c_str(),
        msg->numAtoms, msg->NFILE, msg->NPRIV, msg->NSAVC, msg->NSTEP,
        msg->DELTA, msg->with_unitcell);

    if (ret_code<0) {
      NAMD_err("Writing of DCD header failed!!");
    }
  }

  //  Write out the values for this timestep
  iout << "WRITING TO REPLICA DCD FILE " << msg->dcdIndex << " " << f.filename.c_str() << "\n" << endi;
  float *msgx = (float*) msg->data;
  float *msgy = msgx + msg->numAtoms;
  float *msgz = msgy + msg->numAtoms;
  int ret_code = write_dcdstep(f.fileid, msg->numAtoms, msgx, msgy, msgz,
                                   msg->with_unitcell ? msg->unitcell : 0);
  if (ret_code < 0) NAMD_err("Writing of DCD step failed!!");

  sendReplicaDcdAck(msg->srcPart, (ReplicaDcdAckMsg*) CmiAlloc(sizeof(ReplicaDcdAckMsg)));
}

recvReplicaDcdInit()

void Output::recvReplicaDcdInit

(

ReplicaDcdInitMsg *

msg

)

Definition at line 914 of file Output.C.

References close_dcd_write(), ReplicaDcdInitMsg::data, ReplicaDcdInitMsg::dcdIndex, ReplicaDcdInitMsg::dcdSelectIndex, endi(), iout, sendReplicaDcdAck(), and ReplicaDcdInitMsg::srcPart.

Referenced by recvReplicaDcdInit().

                                                      {
  replicaDcdFile &f = (msg->dcdSelectIndex<16) ? replicaDcdSelectFiles[std::make_pair(msg->dcdIndex,msg->dcdSelectIndex)]: replicaDcdFiles[msg->dcdIndex];
  if ( f.fileid ) {
    iout << "CLOSING REPLICA DCD FILE " << msg->dcdIndex << " " << f.filename.c_str() << "\n" << endi;
    close_dcd_write(f.fileid);
    f.fileid = 0;
  }
  f.filename = (const char*) msg->data;
  sendReplicaDcdAck(msg->srcPart, (ReplicaDcdAckMsg*) CmiAlloc(sizeof(ReplicaDcdAckMsg)));
}

replicaDcdInit()

void Output::replicaDcdInit	(	int	index,
		const char *	filename
	)

Definition at line 888 of file Output.C.

References ReplicaDcdInitMsg::data, ReplicaDcdInitMsg::dcdIndex, ReplicaDcdInitMsg::dcdSelectIndex, sendReplicaDcdInit(), and ReplicaDcdInitMsg::srcPart.

                                                           {
  replicaDcdActive = 1;
  replicaDcdIndex = index;
  int msgsize = sizeof(ReplicaDcdInitMsg) + strlen(filename);
  ReplicaDcdInitMsg *msg = (ReplicaDcdInitMsg *) CmiAlloc(msgsize);
  msg->srcPart = CmiMyPartition();
  msg->dcdIndex = replicaDcdIndex;
  msg->dcdSelectIndex = 16;
  strcpy(msg->data, filename);
  sendReplicaDcdInit(abs(replicaDcdIndex) % CmiNumPartitions(), msg, msgsize);
}

replicaDcdOff()

void Output::replicaDcdOff ( )

inline

Definition at line 173 of file Output.h.

{ replicaDcdActive = 0; }

replicaDcdSelectInit()

void Output::replicaDcdSelectInit	(	int	index,
		const char *	tag,
		const char *	filename
	)

Definition at line 900 of file Output.C.

References ReplicaDcdInitMsg::data, ReplicaDcdInitMsg::dcdIndex, ReplicaDcdInitMsg::dcdSelectIndex, Molecule::find_or_create_dcd_selection_index(), namdMyNode, sendReplicaDcdInit(), and ReplicaDcdInitMsg::srcPart.

                                                                                  {
  replicaDcdActive = 1;
  replicaDcdIndex = index;
  int msgsize = sizeof(ReplicaDcdInitMsg) + strlen(filename);
  ReplicaDcdInitMsg *msg = (ReplicaDcdInitMsg *) CmiAlloc(msgsize);
  msg->srcPart = CmiMyPartition();
  msg->dcdIndex = replicaDcdIndex;
  Molecule *molecule = namdMyNode->molecule;
  msg->dcdSelectIndex = molecule->find_or_create_dcd_selection_index(tag);
  strcpy(msg->data, filename);
  sendReplicaDcdInit(abs(replicaDcdIndex) % CmiNumPartitions(), msg, msgsize);
}

setReplicaDcdIndex()

void Output::setReplicaDcdIndex

(

int

index

)

Definition at line 883 of file Output.C.

                                         {
  replicaDcdActive = 1;
  replicaDcdIndex = index;
}

velocity()

void Output::velocity	(	int	timestep,
		int	n,
		Vector *	vel,
		FloatVector *	fvel
	)

Produce appropriate velocity for the current timestep.

This function receives the velocities accumulated for a given timestep from the Collect object and calls the appropriate output functions. ALL routines used to output velocity information should be called from here.

Parameters

timestep	Timestep velocities were accumulated for
n	The number of velocities accumulated
vel	Array of Vectors containing the velocities in double precision. If the second bit of velocityNeeded is 1, then this parameter shouldn't be nullptr or NULL.
fvel	Array of Vectors containing the velocities in single precision. If the first bit of velocityNeeded is 1, then this parameter shouldn't be nullptr or NULL.

Definition at line 541 of file Output.C.

References END_OF_RUN, endi(), FILE_OUTPUT, IMDOutput::gather_velocities(), Node::imd, IMDv3, iout, Node::Object(), PDBVELFACTOR, Node::simParameters, and simParams.

Referenced by CollectionMaster::disposeVelocities().

{
  SimParameters *simParams = Node::Object()->simParameters;

  if ( timestep >= 0 ) {

    //  Output velocity DCD trajectory
    if ( simParams->velDcdFrequency &&
       ((timestep % simParams->velDcdFrequency) == 0) )
    {
      output_veldcdfile(timestep, n, fvel);
    }

  //  Output restart file
    if ( simParams->restartFrequency &&
       ((timestep % simParams->restartFrequency) == 0) )
    {
      iout << "WRITING VELOCITIES TO RESTART FILE AT STEP "
                                << timestep << "\n" << endi;
      output_restart_velocities(timestep, n, vel);
      iout << "FINISHED WRITING RESTART VELOCITIES\n" <<endi;
      fflush(stdout);
    }

    //  Interactive MD
    if ( simParams->IMDon &&
       ( ((timestep % simParams->IMDfreq) == 0) ||
         (timestep == simParams->firstTimestep) ) &&
         ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.velocities_switch == 1)) )
    {
      IMDOutput *imd = NULL;
#ifdef NODEGROUP_FORCE_REGISTER
      if (simParams->CUDASOAintegrate) {
        CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
        imd = cpdata.ckLocalBranch()->imd;
      }
      else
#endif
      {
        imd = Node::Object()->imd;
      }
      if (imd != NULL) {
        scale_fvels(fvel, n, PDBVELFACTOR);
        imd->gather_velocities(timestep, n, fvel);
      }
    }

  }

  //  Output final velocities
  if (timestep == FILE_OUTPUT || timestep == END_OF_RUN)
  {
    int realstep = ( timestep == FILE_OUTPUT ?
          simParams->firstTimestep : simParams->N );
    iout << "WRITING VELOCITIES TO OUTPUT FILE AT STEP "
                                << realstep << "\n" << endi;
    fflush(stdout);
    output_final_velocities(realstep, n, vel);
  }

  //  Close trajectory files
  if (timestep == END_OF_RUN)
  {
    if (simParams->velDcdFrequency) output_veldcdfile(END_OF_RUN,0,0);
    // close force dcd file here since no final force output below
    if (simParams->forceDcdFrequency) output_forcedcdfile(END_OF_RUN,0,0);
  }

}

velocityNeeded()

int Output::velocityNeeded ( int  timestep )

static

Check if the step requires to output the velocities.

Parameters

timestep

The current step number

Returns

A bitmask indicates whether the step requires to output the velocities. If the return value is 0, then velocities are not required for output. If the first bit of the return value is 1, then the single-precision velocities are required. If the second bit is 1, then the double- precision velocities are required. If both the first and the second bit are 1, then both precisions are required.

Definition at line 502 of file Output.C.

References END_OF_RUN, FILE_OUTPUT, IMDv3, Node::Object(), Node::simParameters, and simParams.

Referenced by Controller::enqueueCollections(), Sequencer::submitCollections(), and Sequencer::submitCollections_SOA().

{
  SimParameters *simParams = Node::Object()->simParameters;

  if(simParams->benchTimestep) return 0;

  int velocitiesNeeded = 0;

  if ( timestep >= 0 ) {

    //  Output a velocity DCD trajectory
    if ( simParams->velDcdFrequency &&
       ((timestep % simParams->velDcdFrequency) == 0) )
      { velocitiesNeeded |= 1; }

    //  Output a restart file
    if ( simParams->restartFrequency &&
       ((timestep % simParams->restartFrequency) == 0) )
      { velocitiesNeeded |= 2; }

    //  Interactive MD
    if ( simParams->IMDon &&
       ( ((timestep % simParams->IMDfreq) == 0) ||
         (timestep == simParams->firstTimestep) ) &&
         ((simParams->IMDversion == IMDversion_t::IMDv3)
         && (simParams->IMDsendsettings.velocities_switch == 1)) )
      { velocitiesNeeded |= 1; }

  }

  //  Output final velocities
  if (timestep == FILE_OUTPUT || timestep == END_OF_RUN)
  {
    velocitiesNeeded |= 2;
  }

  return velocitiesNeeded;
}

Friends And Related Function Documentation

SimParameters

friend class SimParameters

friend

Definition at line 40 of file Output.h.

---

The documentation for this class was generated from the following files:

• Output.h
• Output.C