Skip to content

Commit

Permalink
refs #4201 Fixed bug caused by units conversion in elastic mode
Browse files Browse the repository at this point in the history 
Did I fixed all of these? It seems that conversion between units does not work on the basis of the equations, specified in Wiki
  • Loading branch information
@abuts
abuts committed Dec 7, 2011
1 parent 2fe5e4b commit f2db0a7
Show file tree
Hide file tree
Showing 3 changed files with 100 additions and 54 deletions.
25 changes: 18 additions & 7 deletions Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/ConvertToMDEvents.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -70,8 +70,8 @@ namespace MDAlgorithms
*/
enum AnalMode{
Elastic = 0, //< int emode = 0; Elastic analysis
Direct = 1, //< emode=1; Direct inelastic analysis mode
Indir = 2, //< emode=2; InDirect inelastic analysis mode
Indir = 1, //< emode=1; InDirect inelastic analysis mode
Direct = 2, //< emode=2; Direct inelastic analysis mode
ANY_Mode //< couples with NoQ, means just copying existing data (may be douing units conversion)
};
/// enum describes if there is need to convert workspace units and different units conversion modes
Expand Down Expand Up @@ -152,7 +152,7 @@ namespace MDAlgorithms
// Parts of the identifyMatrixAlg, separated for unit testing:
std::string parseQMode(const std::string &Q_mode_req,const Strings &ws_dim_names,const Strings &ws_dim_units,Strings &out_dim_names,Strings &out_dim_units, int &nQdims);
std::string parseDEMode(const std::string &Q_MODE_ID,const std::string &dE_mode_req,const Strings &ws_dim_units,Strings &out_dim_names,
Strings &out_dim_units, int &ndE_dims,std::string &natural_units, int &emode);
Strings &out_dim_units, int &ndE_dims,std::string &natural_units);
std::string parseConvMode(const std::string &Q_MODE_ID,const std::string &natural_units,const Strings &ws_dim_units);

/** identifies conversion subalgorithm to run on a workspace */
Expand All @@ -163,13 +163,25 @@ namespace MDAlgorithms

/** function provides the linear representation for the transformation matrix, which translate momentums from laboratory to hkl coordinate system */
std::vector<double> getTransfMatrix(API::MatrixWorkspace_sptr inWS2D,const Kernel::V3D &u=Kernel::V3D(1,0,0), const Kernel::V3D &v=Kernel::V3D(0,1,0))const;


/// map to select an algorithm as function of the key, which describes it
std::map<std::string, pMethod> alg_selector;
/// map to select an workspace, as function of the dimensions number
std::map<size_t, pWSCreator> ws_creator;

// strictly for testing!!!
void setAlgoID(const std::string &newID){
this->algo_id=newID;
}
// strictly for testing!!!
void setAlgoUnits(int emode){
if(emode==0){
this->subalgorithm_units=native_elastic_unitID;
}
if(emode==1||emode==2){
this->subalgorithm_units=native_inelastic_unitID;
}
}
private:
//--------------------------------------------------------------------------------------------------
/** generic template to convert to any Dimensions workspace;
Expand Down Expand Up @@ -208,9 +220,8 @@ namespace MDAlgorithms
// The Units (different for different Q and dE mode), for input workspace, for the selected sub algorihm to work with.
// Any other input workspace units have to be converted into these:
std::string subalgorithm_units;
// the variable describing energy transformation mode. (0 -- elastic, 1-- direct; 2 -- indirect)
// assigned by
int emode;
// string -Key to identify the algorithm
std::string algo_id;
//
std::vector<double> getTransfMatrix()const{return rotMatrix;}
//
Expand Down
55 changes: 31 additions & 24 deletions Code/Mantid/Framework/MDAlgorithms/src/ConvertToMDEvents.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -147,11 +147,25 @@ ConvertToMDEvents::getEi(ConvertToMDEvents const *const pHost)
*/
int
ConvertToMDEvents::getEMode(ConvertToMDEvents const *const pHost){
if(pHost->emode<0||pHost->emode>2){
convert_log.error()<<"getEMode: "<<pHost->emode<< " unsupported emode\n";
if(pHost->algo_id.empty()){
convert_log.error()<<"getEMode: emode undefined\n";
throw(std::logic_error(" should not call this function when emode is undefined"));
}
return pHost->emode;
if(pHost->algo_id.find(pHost->dE_modes[Elastic])!=std::string::npos){
// elastic emode
return (int)Elastic;
}
if(pHost->algo_id.find(pHost->dE_modes[Direct])!=std::string::npos){
// direct emode
return (int)Direct;
}
if(pHost->algo_id.find(pHost->dE_modes[Indir])!=std::string::npos){
// indirect emode
return (int)Indir;
}
convert_log.error()<<"getEMode: emode for algorithm with ID: "<<pHost->algo_id<<" not defined \n";
throw(std::logic_error(" can not identify correct emode"));
return -1;
}

//----------------------------------------------------------------------------------------------
Expand Down Expand Up @@ -315,6 +329,8 @@ ConvertToMDEvents::process_detectors_positions(const DataObjects::Workspace2D_co
//----------------------------------------------------------------------------------------------
/* Execute the algorithm. */
void ConvertToMDEvents::exec(){
// in case of subsequent calls
this->algo_id="";
// -------- Input workspace
MatrixWorkspace_sptr inMatrixWS = getProperty("InputWorkspace");
if(!inMatrixWS){
Expand All @@ -337,9 +353,6 @@ void ConvertToMDEvents::exec(){
this ->rotMatrix = getTransfMatrix(inWS2D,u,v);


// string -Key to identify the algorithm
std::string algo_id;

// if new workspace is created, its properties are determened by the user's input
if (create_new_ws){
// what dimension names requested by the user by:
Expand Down Expand Up @@ -447,8 +460,9 @@ ConvertToMDEvents::identifyMatrixAlg(API::MatrixWorkspace_const_sptr inMatrixWS,
// identify Q_mode
Q_MODE_ID = parseQMode (Q_mode_req,ws_dim_names,ws_dim_units,out_dim_names,out_dim_units,nQ_dims);
// identify dE mode
DE_MODE_ID= parseDEMode(Q_MODE_ID,dE_mode_req,ws_dim_units,out_dim_names,out_dim_units,ndE_dims,subalgorithm_units,emode);
DE_MODE_ID= parseDEMode(Q_MODE_ID,dE_mode_req,ws_dim_units,out_dim_names,out_dim_units,ndE_dims,subalgorithm_units);
// identify conversion mode;
this->algo_id=Q_MODE_ID+DE_MODE_ID; // just in case, to resolve cyclic dependence on emode, as CovMode asks for emode
CONV_MODE_ID=parseConvMode(Q_MODE_ID,subalgorithm_units,ws_dim_units);

the_WSalgID = Q_MODE_ID+DE_MODE_ID+CONV_MODE_ID;
Expand Down Expand Up @@ -496,9 +510,9 @@ ConvertToMDEvents::parseConvMode(const std::string &Q_MODE_ID,const std::string
CONV_MODE_ID = ConvModes[ConvFromTOF];
}else{ // convert via TOF
CONV_MODE_ID = ConvModes[ConvByTOF];
if(this->emode == 0){
if(getEMode(this) == 0){
convert_log.error() <<" conversion via TOF is not availible in elastic mode\n";
convert_log.error() <<" can not convert input workspce X-axis units"<<ws_dim_units[0]<<" into"<<getNativeUnitsID(this)
convert_log.error() <<" can not convert input workspce X-axis units: "<<ws_dim_units[0]<<" into: "<<getNativeUnitsID(this)
<<" needed by elastic conversion\n";
throw(std::invalid_argument(" wrong X-axis units"));
}
Expand All @@ -524,7 +538,7 @@ ConvertToMDEvents::parseConvMode(const std::string &Q_MODE_ID,const std::string
*/
std::string
ConvertToMDEvents::parseDEMode(const std::string &Q_MODE_ID,const std::string &dE_mode_req,const Strings &ws_dim_units,Strings &out_dim_names,Strings &out_dim_units,
int &ndE_dims,std::string &natural_units, int &emode)
int &ndE_dims,std::string &natural_units)
{
if(is_member(dE_modes,dE_mode_req)<0){
convert_log.error()<<" dE-mode: "<<dE_mode_req<<" not recognized\n";
Expand All @@ -537,9 +551,7 @@ ConvertToMDEvents::parseDEMode(const std::string &Q_MODE_ID,const std::string &d
if((Q_MODE_ID.compare(Q_modes[NoQ])==0)){
DE_MODE_ID = dE_modes[ANY_Mode];
// no-Q mode -- no conversion, so natural units are the one, already used by the workspace
natural_units=ws_dim_units[0];
// not a conversion mode; should throw later if conversion is requested
emode = 3;
natural_units=ws_dim_units[0];
}
// inelastic modes have one additional dimension and need special units on X-axis
if((DE_MODE_ID.compare(dE_modes[Direct])==0)||(DE_MODE_ID.compare(dE_modes[Indir])==0)){
Expand All @@ -548,16 +560,10 @@ ConvertToMDEvents::parseDEMode(const std::string &Q_MODE_ID,const std::string &d
out_dim_units.push_back("DeltaE");
// natural units defined in subalgorithm doing the conversion and their ID has to be defined correctly in class constructor
natural_units = native_inelastic_unitID;
if(DE_MODE_ID.compare(dE_modes[Direct])==0){
emode=1;
}else{
emode=2;
}
}

if(DE_MODE_ID.compare(dE_modes[Elastic])==0){
natural_units = native_elastic_unitID;
emode = 0;
}
return DE_MODE_ID;

Expand Down Expand Up @@ -676,7 +682,8 @@ ConvertToMDEvents::identifyTheAlg(API::MatrixWorkspace_const_sptr inWS2D,const s
}

// any inelastic mode or unit conversion involing TOF needs Ei to be among the input workspace properties
if((this->emode == 1)||(this->emode == 2)||(the_algID.find("TOD")!=std::string::npos))
int emode = getEMode(this);
if((emode == 1)||(emode == 2)||(the_algID.find("TOD")!=std::string::npos))
{
if(!inWS2D->run().hasProperty("Ei")){
convert_log.error()<<" Conversion sub-algorithm with ID: "<<the_algID<<" needs input energy to be present among run properties\n";
Expand Down Expand Up @@ -714,9 +721,9 @@ ConvertToMDEvents::getAddDimensionNames(MatrixWorkspace_const_sptr inMatrixWS,st
for(size_t i=0;i<run_properties.size();i++){
add_dim_names[i]=run_properties[i]->name();
std::string UnitID = run_properties[i]->units();
if(UnitID.empty()||(UnitID.compare("Empty")==0)){ // it is questionable if we want to have unit ID equal to the dimension name and not empty
UnitID =add_dim_names[i];
}
// if(UnitID.empty()||(UnitID.compare("Empty")==0)){ // it is questionable if we want to have unit ID equal to the dimension name and not empty
// UnitID =add_dim_names[i];
//}
add_dim_units[i]=UnitID;
}

Expand Down Expand Up @@ -813,7 +820,7 @@ class LOOP_ND<2,Q,MODE,CONV>{
* needs to pick up all known algorithms.
*/
ConvertToMDEvents::ConvertToMDEvents():
emode(-1),
algo_id(""),
Q_modes(3),
dE_modes(4),
ConvModes(4)
Expand Down
74 changes: 51 additions & 23 deletions Code/Mantid/Framework/MDAlgorithms/test/ConvertToMDEventsTest.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,14 +48,21 @@ class Convert2AnyTestHelper: public ConvertToMDEvents
//
std::string parseDEMode(const std::string &Q_MODE_ID,const std::string &dE_mode_req,const std::vector<std::string> &ws_dim_units,
std::vector<std::string> &out_dim_names,std::vector<std::string> &out_dim_units,
int &ndE_dims,std::string &natural_units,int &emode)
int &ndE_dims,std::string &natural_units)
{
return ConvertToMDEvents::parseDEMode(Q_MODE_ID,dE_mode_req,ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode);
return ConvertToMDEvents::parseDEMode(Q_MODE_ID,dE_mode_req,ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units);

}
std::string parseConvMode(const std::string &Q_MODE_ID,const std::string &natural_units,const std::vector<std::string> &ws_dim_units){
return ConvertToMDEvents::parseConvMode(Q_MODE_ID,natural_units,ws_dim_units);
}

void setAlgoID(const std::string &newID){
ConvertToMDEvents::setAlgoID(newID);
}
void setAlgoUnits(int emode){
ConvertToMDEvents::setAlgoUnits(emode);
}


//std::string identify_requested_alg(const std::vector<std::string> &dim_names_availible, const std::string &QOption,const std::vector<std::string> &dim_selected,size_t &nDims)
Expand Down Expand Up @@ -160,22 +167,22 @@ void testParseDEMode_WrongThrows()

std::vector<std::string> ws_dim_units;
std::vector<std::string> out_dim_names,out_dim_units;
int ndE_dims,emode;
int ndE_dims;
std::string natural_units;

TS_ASSERT_THROWS(pAlg->parseDEMode("SOMEQMODE","WrongMode",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode),std::invalid_argument);
TS_ASSERT_THROWS(pAlg->parseDEMode("SOMEQMODE","WrongMode",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units),std::invalid_argument);
}
void testParseDEMode_NoQ()
{
std::vector<std::string> ws_dim_units(1,"some");
std::vector<std::string> out_dim_names,out_dim_units;
int ndE_dims,emode;
int ndE_dims;
std::string natural_units;
std::string EID;

TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("","Elastic",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode));
TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("","Elastic",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units));
TS_ASSERT_EQUALS(0,ndE_dims);
TS_ASSERT_EQUALS(3,emode);

TSM_ASSERT_EQUALS("Regardless of the dE mode, if Q-mode is NoQ, should return Any_Mode: ","",EID);
TS_ASSERT(out_dim_names.empty());
TS_ASSERT(out_dim_units.empty());
Expand All @@ -185,13 +192,13 @@ void testParseDEMode_InelasticDirect()
{
std::vector<std::string> ws_dim_units(1,"some");
std::vector<std::string> out_dim_names,out_dim_units;
int ndE_dims,emode;
int ndE_dims;
std::string natural_units;
std::string EID;

TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("DoesNotMatter","Direct",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode));
TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("DoesNotMatter","Direct",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units));
TS_ASSERT_EQUALS(1,ndE_dims);
TS_ASSERT_EQUALS(1,emode);

TS_ASSERT_EQUALS("Direct",EID);
TS_ASSERT_EQUALS("DeltaE",out_dim_names[0]);
TS_ASSERT_EQUALS("DeltaE",out_dim_units[0]);
Expand All @@ -201,13 +208,12 @@ void testParseDEMode_InelasticInDir()
{
std::vector<std::string> ws_dim_units(1,"some");
std::vector<std::string> out_dim_names,out_dim_units;
int ndE_dims,emode;
int ndE_dims;
std::string natural_units;
std::string EID;

TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("DoesNotMatter","Indirect",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode));
TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("DoesNotMatter","Indirect",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units));
TS_ASSERT_EQUALS(1,ndE_dims);
TS_ASSERT_EQUALS(2,emode);
TS_ASSERT_EQUALS("Indirect",EID);
TS_ASSERT_EQUALS("DeltaE",out_dim_names[0]);
TS_ASSERT_EQUALS("DeltaE",out_dim_units[0]);
Expand All @@ -217,13 +223,12 @@ void testParseDEMode_Elastic()
{
std::vector<std::string> ws_dim_units(1,"some");
std::vector<std::string> out_dim_names,out_dim_units;
int ndE_dims,emode;
int ndE_dims;
std::string natural_units;
std::string EID;

TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("DoesNotMatter","Elastic",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode));
TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("DoesNotMatter","Elastic",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units));
TS_ASSERT_EQUALS(0,ndE_dims);
TS_ASSERT_EQUALS(0,emode);
TS_ASSERT_EQUALS("Elastic",EID);
TS_ASSERT(out_dim_names.empty());
TS_ASSERT(out_dim_units.empty());
Expand All @@ -233,13 +238,12 @@ void testParseDEMode_ElasticPowd()
{
std::vector<std::string> ws_dim_units(1,"some");
std::vector<std::string> out_dim_names,out_dim_units;
int ndE_dims,emode;
int ndE_dims;
std::string natural_units;
std::string EID;

TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("|Q|","Elastic",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units,emode));
TS_ASSERT_THROWS_NOTHING(EID=pAlg->parseDEMode("|Q|","Elastic",ws_dim_units,out_dim_names,out_dim_units,ndE_dims,natural_units));
TS_ASSERT_EQUALS(0,ndE_dims);
TS_ASSERT_EQUALS(0,emode);
TS_ASSERT_EQUALS("Elastic",EID);
TS_ASSERT(out_dim_names.empty());
TS_ASSERT(out_dim_units.empty());
Expand All @@ -253,6 +257,16 @@ void testParseConv_NonConvertUnitThrows()

TS_ASSERT_THROWS(pAlg->parseConvMode("AnyConversionMode",natural_units,ws_dim_units),std::invalid_argument);
}
void testParseConv_ElasticViaTOFThrows()
{
std::vector<std::string> ws_dim_units(1,"DeltaE");
std::string natural_units;
// satisfy internal dependancies
pAlg->setAlgoID("blaBla-Elastic-BlaBlaBla");
pAlg->setAlgoUnits(0);

TS_ASSERT_THROWS(pAlg->parseConvMode("Elastic",natural_units,ws_dim_units),std::invalid_argument);
}
void testParseConv_NoQ()
{
std::vector<std::string> ws_dim_units(1,"Any");
Expand Down Expand Up @@ -289,6 +303,10 @@ void testParseConv_ByTOF()
{
std::vector<std::string> ws_dim_units(1,"DeltaE");
std::string CONV_ID;
// satisfy internal dependancies
pAlg->setAlgoID("blaBla-Direct-BlaBlaBla");
pAlg->setAlgoUnits(1);


TS_ASSERT_THROWS_NOTHING(CONV_ID=pAlg->parseConvMode("AnyMode","Wavelength",ws_dim_units));
TS_ASSERT_EQUALS("CnvByTOF",CONV_ID);
Expand Down Expand Up @@ -316,6 +334,11 @@ void testGetWS4DimIDFine(){
}
void testGetWS3DimIDFine(){
Mantid::API::MatrixWorkspace_sptr ws2D =WorkspaceCreationHelper::createProcessedWorkspaceWithCylComplexInstrument(4,10,true);
API::NumericAxis *pAx = new API::NumericAxis(3);
pAx->title() = "Dim1";
pAx->setUnit("dSpacing");
ws2D->replaceAxis(0,pAx);


std::vector<std::string> dim_names;
std::vector<std::string> dim_units;
Expand All @@ -324,7 +347,7 @@ void testGetWS3DimIDFine(){

TSM_ASSERT_EQUALS("Inelastic workspace will produce 3 dimensions",3,dim_names.size());
TSM_ASSERT_EQUALS("Last dimension of Elastic transformation should be ","MomentumTransfer",dim_units[2]);
TSM_ASSERT_EQUALS("Alg ID would be: ","QxQyQzElasticCnvByTOF",Alg_ID);
TSM_ASSERT_EQUALS("Alg ID would be: ","QxQyQzElasticCnvFast",Alg_ID);

}
void testGetWSDimNames2AxisNoQ(){
Expand Down Expand Up @@ -414,15 +437,20 @@ void testIdentifyMatrixAlg_2()
pAx = new API::NumericAxis(3);
pAx->setUnit("Wavelength");
ws2D->replaceAxis(0,pAx);
TSM_ASSERT_THROWS_NOTHING("Elastic conversion needs X-axis to be in an Energy-related units",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units));
// This is probably bug in conversion --> does not work in elastic mode
//TSM_ASSERT_THROWS_NOTHING("Elastic conversion needs X-axis to be in an Energy-related units",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units));
TSM_ASSERT_THROWS("Can not convert wavelength to momentum transfer in elastic mode ",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units),std::invalid_argument);

pAx = new API::NumericAxis(3);
pAx->setUnit("Energy");
ws2D->replaceAxis(0,pAx);
TSM_ASSERT_THROWS_NOTHING("Elastic conversion needs X-axis to be in an Energy-related units",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units));
// This is probably bug in conversion --> does not work in elastic mode
//TSM_ASSERT_THROWS_NOTHING("Elastic conversion needs X-axis to be in an Energy-related units",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units));
TSM_ASSERT_THROWS("Can not convert Energy to momentum transfer in elastic mode ",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units),std::invalid_argument);


pAx = new API::NumericAxis(3);
pAx->setUnit("Energy_inWavenumber");
pAx->setUnit("dSpacing");
ws2D->replaceAxis(0,pAx);
TSM_ASSERT_THROWS_NOTHING("Elastic conversion needs X-axis to be in an Energy-related units",pAlg->identifyMatrixAlg(ws2D,"|Q|","Elastic",dim_names,dim_units));

Expand Down

0 comments on commit f2db0a7

Please sign in to comment.