Output Class Reference

#include <Output.h>

Public Member Functions
	Output ()
	~Output ()
void	energy (int, BigReal *)
void	coordinate (int, int, Vector *, FloatVector *, Lattice &)
void	velocity (int, int, Vector *)
void	force (int, int, Vector *)
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)
static int	velocityNeeded (int)
static int	forceNeeded (int)

Friends
class	SimParameters

Detailed Description

Definition at line 35 of file Output.h.

Constructor & Destructor Documentation

Output()

Output::Output

(

)

Definition at line 169 of file Output.C.

: replicaDcdActive(0) { }

~Output()

Output::~Output

(

)

Definition at line 179 of file Output.C.

{ }

Member Function Documentation

coordinate()

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

Definition at line 345 of file Output.C.

References Molecule::dcdSelectionParams, END_OF_RUN, endi(), EVAL_MEASURE, FILE_OUTPUT, dcd_params::frequency, IMDOutput::gather_coordinates(), Molecule::get_dcd_selection_index_from_atom_id(), Molecule::get_dcd_selection_size(), Node::getScript(), Node::imd, iout, ScriptTcl::measure(), Node::molecule, Node::Object(), Node::simParameters, simParams, dcd_params::size, dcd_params::tag, wrap_coor(), and wrap_coor_dcd_selection().

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) ) )
    {
      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;
      }
      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

Definition at line 199 of file Output.C.

References Molecule::dcdSelectionParams, END_OF_RUN, EVAL_MEASURE, FILE_OUTPUT, dcd_params::frequency, 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;
        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(dcdSelectionTag>0)
                  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) ) )
      { 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
	)

Definition at line 621 of file Output.C.

References endi(), FORCE_OUTPUT, 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, frc);
    }

  }

  //  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

Definition at line 595 of file Output.C.

References FORCE_OUTPUT, 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; }

  }

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

  return forcesNeeded;
}

recvReplicaDcdData()

void Output::recvReplicaDcdData

(

ReplicaDcdDataMsg *

msg

)

Definition at line 880 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 869 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 843 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 93 of file Output.h.

{ replicaDcdActive = 0; }

replicaDcdSelectInit()

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

Definition at line 855 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 838 of file Output.C.

                                         {
  replicaDcdActive = 1;
  replicaDcdIndex = index;
}

velocity()

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

Definition at line 531 of file Output.C.

References END_OF_RUN, endi(), FILE_OUTPUT, iout, Node::Object(), 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, vel);
    }

  //  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);
    }

  }

  //  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

Definition at line 500 of file Output.C.

References END_OF_RUN, FILE_OUTPUT, 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; }

  }

  //  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