void NhsContractionModel::EvaluateYDerivatives(double time,
const std::vector<double> &rY,
std::vector<double> &rDY)
{
//// if making changes here, see also NhsModelWithBackwardSolver::CalculateCaTropAndZDerivatives()
const double& calcium_troponin = rY[0];
const double& z = rY[1];
const double& Q1 = rY[2];
const double& Q2 = rY[3];
const double& Q3 = rY[4];
// check the state vars are in the expected range
#define COVERAGE_IGNORE
if(calcium_troponin < 0)
{
EXCEPTION("CalciumTrop concentration went negative");
}
if(z<0)
{
EXCEPTION("z went negative");
}
if(z>1)
{
EXCEPTION("z became greater than 1");
}
#undef COVERAGE_IGNORE
double Q = Q1 + Q2 + Q3;
double T0 = CalculateT0(z);
double Ta;
if(Q>0)
{
Ta = T0*(1+(2+mA)*Q)/(1+Q);
}
else
{
Ta = T0*(1+mA*Q)/(1-Q);
}
rDY[0] = mKon * mCalciumI * ( mCalciumTroponinMax - calcium_troponin)
- mKrefoff * (1-Ta/(mGamma*mTref)) * calcium_troponin;
double ca_trop_to_ca_trop50_ratio_to_n = SmallPow(calcium_troponin/mCalciumTrop50, mN);
rDY[1] = mAlpha0 * ca_trop_to_ca_trop50_ratio_to_n * (1-z)
- mAlphaR1 * z
- mAlphaR2 * SmallPow(z,mNr) / (SmallPow(z,mNr) + SmallPow(mKZ,mNr));
rDY[2] = mA1 * mDLambdaDt - mAlpha1 * Q1;
rDY[3] = mA2 * mDLambdaDt - mAlpha2 * Q2;
rDY[4] = mA3 * mDLambdaDt - mAlpha3 * Q3;
}
double NhsContractionModel::GetActiveTension()
{
double T0 = CalculateT0(mStateVariables[1]);
double Q = mStateVariables[2]+mStateVariables[3]+mStateVariables[4];
if(Q>0)
{
return T0*(1+(2+mA)*Q)/(1+Q);
}
else
{
return T0*(1+mA*Q)/(1-Q);
}
}
double NhsModelWithBackwardSolver::GetNextActiveTension()
{
double T0 = CalculateT0(mTemporaryStateVariables[1]);
double Q = mTemporaryStateVariables[2]+mTemporaryStateVariables[3]+mTemporaryStateVariables[4];
if(Q>0)
{
return T0*(1+(2+mA)*Q)/(1+Q);
}
else
{
return T0*(1+mA*Q)/(1-Q);
}
}
void NhsModelWithBackwardSolver::CalculateCaTropAndZDerivatives(double calciumTroponin, double z, double Q,
double& dCaTrop, double& dz)
{
//As in straight Nhs, we don't cover the exception code
#define COVERAGE_IGNORE
if(calciumTroponin < 0)
{
EXCEPTION("CalciumTrop concentration went negative");
}
if(z<0)
{
EXCEPTION("z went negative");
}
if(z>1)
{
EXCEPTION("z became greater than 1");
}
#undef COVERAGE_IGNORE
double T0 = CalculateT0(z);
double Ta;
if(Q>0)
{
Ta = T0*(1+(2+mA)*Q)/(1+Q);
}
else
{
Ta = T0*(1+mA*Q)/(1-Q);
}
dCaTrop = mKon * mCalciumI * ( mCalciumTroponinMax - calciumTroponin)
- mKrefoff * (1-Ta/(mGamma*mTref)) * calciumTroponin;
double ca_trop_to_ca_trop50_ratio_to_n = pow(calciumTroponin/mCalciumTrop50, mN);
dz = mAlpha0 * ca_trop_to_ca_trop50_ratio_to_n * (1-z)
- mAlphaR1 * z
- mAlphaR2 * pow(z,mNr) / (pow(z,mNr) + pow(mKZ,mNr));
}
void ModeratorTzero::exec()
{
m_tolTOF = getProperty("tolTOF"); //Tolerance in the calculation of the emission time, in microseconds
m_niter=getProperty("Niter"); // number of iterations
const MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace");
m_instrument = inputWS->getInstrument(); // pointer to the instrument
//deltaE-mode (should be "indirect")
std::vector<std::string> Emode=m_instrument->getStringParameter("deltaE-mode");
if(Emode.empty())
throw Exception::InstrumentDefinitionError("Unable to retrieve instrument geometry (direct or indirect) parameter", inputWS->getTitle());
if(Emode[0]!= "indirect")
throw Exception::InstrumentDefinitionError("Instrument geometry must be of type indirect.");
// extract formula from instrument parameters
std::vector<std::string> t0_formula=m_instrument->getStringParameter("t0_formula");
if(t0_formula.empty()) throw Exception::InstrumentDefinitionError("Unable to retrieve t0_formula among instrument parameters");
m_formula=t0_formula[0];
//Run execEvent if eventWorkSpace
EventWorkspace_const_sptr eventWS = boost::dynamic_pointer_cast<const EventWorkspace>(inputWS);
if (eventWS != NULL)
{
execEvent();
return;
}
MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace");
//Check whether input == output to see whether a new workspace is required.
if ( outputWS != inputWS )
{
//Create new workspace for output from old
outputWS = WorkspaceFactory::Instance().create(inputWS);
}
const size_t numHists = static_cast<size_t>(inputWS->getNumberHistograms());
Progress prog(this,0.0,1.0,numHists); //report progress of algorithm
PARALLEL_FOR2(inputWS, outputWS)
// iterate over the spectra
for (int i=0; i < static_cast<int>(numHists); ++i)
{
PARALLEL_START_INTERUPT_REGION
size_t wsIndex = static_cast<size_t>(i);
double L1=CalculateL1(inputWS, wsIndex); // distance from source to sample or monitor
double t2=CalculateT2(inputWS, wsIndex); // time from sample to detector
// shift the time of flights by the emission time from the moderator
if(t2 >= 0) //t2 < 0 when no detector info is available
{
double E1;
mu::Parser parser;
parser.DefineVar("incidentEnergy", &E1); // associate E1 to this parser
parser.SetExpr(m_formula);
E1=m_convfactor*(L1/m_t1min)*(L1/m_t1min);
double min_t0_next=parser.Eval(); // fast neutrons are shifted by min_t0_next, irrespective of tof
MantidVec &inbins = inputWS->dataX(i);
MantidVec &outbins = outputWS->dataX(i);
// iterate over the time-of-flight values
for(unsigned int ibin=0; ibin < inbins.size(); ibin++)
{
double tof=inbins[ibin]; // current time-of-flight
if(tof<m_t1min+t2)
tof-=min_t0_next;
else
tof-=CalculateT0(tof, L1, t2, E1, parser);
outbins[ibin] = tof;
}
}
else
{
outputWS->dataX(i) = inputWS->dataX(i);
}
//Copy y and e data
outputWS->dataY(i) = inputWS->dataY(i);
outputWS->dataE(i) = inputWS->dataE(i);
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// Copy units
if (inputWS->getAxis(0)->unit().get())
{
outputWS->getAxis(0)->unit() = inputWS->getAxis(0)->unit();
}
try
{
if(inputWS->getAxis(1)->unit().get())
{
outputWS->getAxis(1)->unit() = inputWS->getAxis(1)->unit();
}
}
catch(Exception::IndexError &) {
// OK, so this isn't a Workspace2D
}
// Assign it to the output workspace property
setProperty("OutputWorkspace",outputWS);
}
void ModeratorTzero::execEvent()
{
g_log.information("Processing event workspace");
const MatrixWorkspace_const_sptr matrixInputWS = getProperty("InputWorkspace");
EventWorkspace_const_sptr inputWS= boost::dynamic_pointer_cast<const EventWorkspace>(matrixInputWS);
// generate the output workspace pointer
const size_t numHists = static_cast<size_t>(inputWS->getNumberHistograms());
Mantid::API::MatrixWorkspace_sptr matrixOutputWS = getProperty("OutputWorkspace");
EventWorkspace_sptr outputWS;
if (matrixOutputWS == matrixInputWS)
{
outputWS = boost::dynamic_pointer_cast<EventWorkspace>(matrixOutputWS);
}
else
{
//Make a brand new EventWorkspace
outputWS = boost::dynamic_pointer_cast<EventWorkspace>(WorkspaceFactory::Instance().create("EventWorkspace", numHists, 2, 1));
//Copy geometry over.
WorkspaceFactory::Instance().initializeFromParent(inputWS, outputWS, false);
//You need to copy over the data as well.
outputWS->copyDataFrom( (*inputWS) );
//Cast to the matrixOutputWS and save it
matrixOutputWS = boost::dynamic_pointer_cast<MatrixWorkspace>(outputWS);
setProperty("OutputWorkspace", matrixOutputWS);
}
//Get a pointer to the sample
IComponent_const_sptr sample = outputWS->getInstrument()->getSample();
// Loop over the spectra
Progress prog(this,0.0,1.0,numHists); //report progress of algorithm
PARALLEL_FOR1(outputWS)
for (int i = 0; i < static_cast<int>(numHists); ++i)
{
PARALLEL_START_INTERUPT_REGION
size_t wsIndex = static_cast<size_t>(i);
EventList &evlist=outputWS->getEventList(wsIndex);
if( evlist.getNumberEvents() > 0 ) //don't bother with empty lists
{
double L1=CalculateL1(matrixOutputWS, wsIndex); // distance from source to sample or monitor
double t2=CalculateT2(matrixOutputWS, wsIndex); // time from sample to detector
if(t2>=0) //t2 < 0 when no detector info is available
{
double tof, E1;
mu::Parser parser;
parser.DefineVar("incidentEnergy", &E1); // associate variable E1 to this parser
parser.SetExpr(m_formula);
E1=m_convfactor*(L1/m_t1min)*(L1/m_t1min);
double min_t0_next=parser.Eval(); // fast neutrons are shifted by min_t0_next, irrespective of tof
// fix the histogram bins
MantidVec &x=evlist.dataX();
for (MantidVec::iterator iter=x.begin(); iter!=x.end(); ++iter)
{
tof=*iter;
if(tof<m_t1min+t2)
tof-=min_t0_next;
else
tof-=CalculateT0(tof, L1, t2, E1, parser);
*iter=tof;
}
MantidVec tofs=evlist.getTofs();
for(unsigned int itof=0; itof<tofs.size(); itof++)
{
tof=tofs[itof]+0.002*(rand()%100 -50); // add a [-0.1,0.1] microsecond noise to avoid artifacts resulting from original tof data
if(tof<m_t1min+t2)
tof-=min_t0_next;
else
tof-=CalculateT0(tof, L1, t2, E1, parser);
tofs[itof]=tof;
}
evlist.setTofs(tofs);
evlist.setSortOrder(Mantid::DataObjects::EventSortType::UNSORTED);
}
}
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputWS->clearMRU(); // Clears the Most Recent Used lists */
} // end of void ModeratorTzero::execEvent()
